feat: update existing files for provider toggle and proxy system

admin_router.py

@@ -773,10 +773,7 @@ async def restart_portal_with_proxy(provider: str):
         # Get current proxy
         current_proxy = proxy_mgr.get_current_proxy()
         if not current_proxy:
-            # Fetch and test a new one
-            current_proxy = await proxy_mgr.get_working_proxy()
-            if not current_proxy:
-                raise HTTPException(status_code=503, detail="No working proxy available")
+            raise HTTPException(status_code=503, detail="No custom proxy configured. Set one first.")
         
         # Close existing portal
         await portal.close()
@@ -794,3 +791,137 @@ async def restart_portal_with_proxy(provider: str):
         raise
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
+
+
+# --- Provider Toggle Management ---
+
+class ProviderToggleRequest(BaseModel):
+    provider_id: str
+    enabled: bool
+
+@router.get("/providers")
+async def get_providers():
+    """Get all providers with their enabled/disabled status."""
+    try:
+        from provider_state import get_provider_state_manager
+        
+        manager = await get_provider_state_manager()
+        providers = manager.get_all_providers()
+        
+        return {
+            "providers": [
+                {
+                    "id": provider_id,
+                    "name": config["name"],
+                    "type": config["type"],
+                    "enabled": config["enabled"]
+                }
+                for provider_id, config in providers.items()
+            ]
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/providers/toggle")
+async def toggle_provider(req: ProviderToggleRequest):
+    """Enable or disable a provider."""
+    try:
+        from provider_state import get_provider_state_manager
+        
+        manager = await get_provider_state_manager()
+        success = await manager.set_provider_state(req.provider_id, req.enabled)
+        
+        if success:
+            return {
+                "status": "success",
+                "provider_id": req.provider_id,
+                "enabled": req.enabled,
+                "message": f"Provider '{req.provider_id}' {'enabled' if req.enabled else 'disabled'}"
+            }
+        else:
+            raise HTTPException(status_code=400, detail=f"Failed to toggle provider '{req.provider_id}'")
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# --- Custom Proxy Management ---
+
+class SetProxyRequest(BaseModel):
+    proxy: str  # Format: ip:port or protocol://ip:port
+
+@router.post("/proxy/set")
+async def set_custom_proxy(req: SetProxyRequest):
+    """Set a custom proxy for the entire container."""
+    try:
+        from proxy_manager import get_proxy_manager
+        
+        proxy_mgr = get_proxy_manager()
+        success = proxy_mgr.set_custom_proxy(req.proxy)
+        
+        if success:
+            return {
+                "status": "success",
+                "proxy": req.proxy,
+                "message": "Custom proxy set successfully"
+            }
+        else:
+            raise HTTPException(status_code=400, detail="Invalid proxy format")
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/proxy/clear")
+async def clear_custom_proxy():
+    """Clear the custom proxy."""
+    try:
+        from proxy_manager import get_proxy_manager
+        
+        proxy_mgr = get_proxy_manager()
+        proxy_mgr.clear_proxy()
+        
+        return {
+            "status": "success",
+            "message": "Custom proxy cleared"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/proxy/status")
+async def get_proxy_status():
+    """Get current proxy status."""
+    try:
+        from proxy_manager import get_proxy_manager
+        
+        proxy_mgr = get_proxy_manager()
+        status = proxy_mgr.get_status()
+        
+        return status
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/proxy/test")
+async def test_custom_proxy():
+    """Test if the current custom proxy is working."""
+    try:
+        from proxy_manager import get_proxy_manager
+        
+        proxy_mgr = get_proxy_manager()
+        
+        if not proxy_mgr.get_current_proxy():
+            raise HTTPException(status_code=400, detail="No custom proxy configured")
+        
+        is_working = await proxy_mgr.test_proxy()
+        status = proxy_mgr.get_status()
+        
+        return {
+            "status": "success",
+            "is_working": is_working,
+            **status
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

browser_portal.py

@@ -88,7 +88,7 @@ PORTAL_CONFIGS = {
 
 
 class BrowserPortal:
-    """Manages an interactive browser session."""
+    """Manages an interactive browser session with auto-refresh on DOM changes."""
     
     def __init__(self, provider: PortalProvider, config: PortalConfig):
         self.provider = provider
@@ -103,6 +103,9 @@ class BrowserPortal:
         self.message_queue = []
         self.last_activity = None
         self.is_logged_in = False
+        self._dom_change_task = None
+        self._last_dom_hash = None
+        self._auto_refresh_enabled = True
         
     async def initialize(self, headless: bool = True, proxy: Optional[Any] = None):
         """Initialize the browser with enhanced stealth and optional proxy."""
@@ -171,6 +174,10 @@ class BrowserPortal:
             
             await self.take_screenshot()
             
+            # Start DOM monitoring for auto-refresh
+            if self._auto_refresh_enabled:
+                await self.start_dom_monitoring()
+            
         except Exception as e:
             logger.error(f"Failed to initialize portal [{self.provider.value}]: {e}")
             raise
@@ -411,6 +418,9 @@ class BrowserPortal:
     async def close(self):
         """Close the browser."""
         try:
+            # Stop DOM monitoring first
+            await self.stop_dom_monitoring()
+            
             if self.browser:
                 await self.browser.close()
             if self.playwright:
@@ -428,6 +438,92 @@ class BrowserPortal:
             return self.browser.is_connected()
         except:
             return False
+    
+    async def start_dom_monitoring(self):
+        """Start monitoring DOM changes and auto-refresh screenshot."""
+        if not self._auto_refresh_enabled or self._dom_change_task:
+            return
+        
+        self._dom_change_task = asyncio.create_task(self._dom_monitoring_loop())
+        logger.info(f"Portal [{self.provider.value}]: DOM monitoring started")
+    
+    async def stop_dom_monitoring(self):
+        """Stop DOM monitoring."""
+        if self._dom_change_task:
+            self._dom_change_task.cancel()
+            try:
+                await self._dom_change_task
+            except asyncio.CancelledError:
+                pass
+            self._dom_change_task = None
+            logger.info(f"Portal [{self.provider.value}]: DOM monitoring stopped")
+    
+    async def _dom_monitoring_loop(self):
+        """Monitor DOM for changes and refresh screenshot when needed."""
+        import hashlib
+        
+        check_interval = 2.0  # Check every 2 seconds
+        
+        while self.is_running() and self._auto_refresh_enabled:
+            try:
+                if self.page:
+                    # Get a hash of the current DOM content
+                    current_hash = await self.page.evaluate("""
+                        () => {
+                            // Get visible text content from main content areas
+                            const selectors = [
+                                'main', 'article', '[role="main"]',
+                                '.chat-content', '.message-content',
+                                '[data-message-author-role]',
+                                '.conversation', '.response'
+                            ];
+                            
+                            let content = '';
+                            for (const sel of selectors) {
+                                const el = document.querySelector(sel);
+                                if (el) {
+                                    content += el.innerText || el.textContent || '';
+                                }
+                            }
+                            
+                            // Fallback to body if no content areas found
+                            if (!content) {
+                                content = document.body ? (document.body.innerText || '') : '';
+                            }
+                            
+                            // Simple hash of the content
+                            let hash = 0;
+                            for (let i = 0; i < content.length; i++) {
+                                const char = content.charCodeAt(i);
+                                hash = ((hash << 5) - hash) + char;
+                                hash = hash & hash;
+                            }
+                            return hash.toString();
+                        }
+                    """)
+                    
+                    # If hash changed, DOM has updated
+                    if self._last_dom_hash is not None and current_hash != self._last_dom_hash:
+                        logger.info(f"Portal [{self.provider.value}]: DOM change detected, refreshing screenshot")
+                        await self.take_screenshot()
+                    
+                    self._last_dom_hash = current_hash
+                
+                await asyncio.sleep(check_interval)
+                
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.debug(f"Portal [{self.provider.value}]: DOM monitoring error: {e}")
+                await asyncio.sleep(check_interval)
+    
+    def set_auto_refresh(self, enabled: bool):
+        """Enable or disable auto-refresh on DOM changes."""
+        self._auto_refresh_enabled = enabled
+        if enabled and self.is_running():
+            asyncio.create_task(self.start_dom_monitoring())
+        elif not enabled:
+            asyncio.create_task(self.stop_dom_monitoring())
 
 
 # Portal manager

config.py

@@ -20,114 +20,14 @@ MODEL_RANKING = [
     ("zai-glm-5", "zai", "glm-5"),
     ("gemini-gemini-3-flash", "gemini", "gemini-3-flash"),
     
-    # Tier 2 — Copilot (GPT-4 via Microsoft)
-    ("copilot-gpt-4", "copilot", "copilot-gpt-4"),
-    
-    # Tier 3 — HuggingChat Models (Top 20 by popularity/quality)
-    ("huggingchat-omni", "huggingchat", "omni"),
-    ("huggingchat-llama-3.3-70b", "huggingchat", "meta-llama/Llama-3.3-70B-Instruct"),
-    ("huggingchat-llama-4-scout", "huggingchat", "meta-llama/Llama-4-Scout-17B-16E-Instruct"),
-    ("huggingchat-llama-4-maverick", "huggingchat", "meta-llama/Llama-4-Maverick-17B-128E-Instruct"),
-    ("huggingchat-kimi-k2.5", "huggingchat", "moonshotai/Kimi-K2.5"),
-    ("huggingchat-kimi-k2", "huggingchat", "moonshotai/Kimi-K2-Instruct"),
-    ("huggingchat-qwen3-235b", "huggingchat", "Qwen/Qwen3-235B-A22B"),
-    ("huggingchat-qwen3-32b", "huggingchat", "Qwen/Qwen3-32B"),
-    ("huggingchat-qwen3-14b", "huggingchat", "Qwen/Qwen3-14B"),
-    ("huggingchat-qwen3-8b", "huggingchat", "Qwen/Qwen3-8B"),
-    ("huggingchat-qwen2.5-72b", "huggingchat", "Qwen/Qwen2.5-72B-Instruct"),
-    ("huggingchat-qwen2.5-32b", "huggingchat", "Qwen/Qwen2.5-32B-Instruct"),
-    ("huggingchat-qwen2.5-7b", "huggingchat", "Qwen/Qwen2.5-7B-Instruct"),
-    ("huggingchat-qwen3-coder-480b", "huggingchat", "Qwen/Qwen3-Coder-480B-A35B-Instruct"),
-    ("huggingchat-qwen3-coder-30b", "huggingchat", "Qwen/Qwen3-Coder-30B-A3B-Instruct"),
-    ("huggingchat-deepseek-r1", "huggingchat", "deepseek-ai/DeepSeek-R1"),
-    ("huggingchat-deepseek-v3", "huggingchat", "deepseek-ai/DeepSeek-V3"),
-    ("huggingchat-deepseek-v3.2", "huggingchat", "deepseek-ai/DeepSeek-V3.2"),
-    ("huggingchat-zai-glm-5", "huggingchat", "zai-org/GLM-5"),
-    ("huggingchat-zai-glm-4.7", "huggingchat", "zai-org/GLM-4.7"),
-    ("huggingchat-zai-glm-4.5", "huggingchat", "zai-org/GLM-4.5"),
-    ("huggingchat-minimax-m2.5", "huggingchat", "MiniMaxAI/MiniMax-M2.5"),
-    ("huggingchat-minimax-m2.1", "huggingchat", "MiniMaxAI/MiniMax-M2.1"),
-    ("huggingchat-minimax-m2", "huggingchat", "MiniMaxAI/MiniMax-M2"),
-    
-    # Tier 3 — Pollinations
+    # Tier 2 — Pollinations
     ("pollinations-gpt-oss-20b", "pollinations", "openai"),
     ("pollinations-mistral-small-3.2", "pollinations", "mistral"),
     ("pollinations-bidara", "pollinations", "bidara"),
     ("pollinations-chickytutor", "pollinations", "chickytutor"),
     ("pollinations-midijourney", "pollinations", "midijourney"),
     
-    # Tier 4 — HuggingChat Additional Models
-    ("huggingchat-llama-3.1-70b", "huggingchat", "meta-llama/Meta-Llama-3-70B-Instruct"),
-    ("huggingchat-llama-3.1-8b", "huggingchat", "meta-llama/Llama-3.1-8B-Instruct"),
-    ("huggingchat-llama-3.2-3b", "huggingchat", "meta-llama/Llama-3.2-3B-Instruct"),
-    ("huggingchat-llama-3.2-1b", "huggingchat", "meta-llama/Llama-3.2-1B-Instruct"),
-    ("huggingchat-llama-3-8b", "huggingchat", "meta-llama/Meta-Llama-3-8B-Instruct"),
-    ("huggingchat-qwen3-vl-235b", "huggingchat", "Qwen/Qwen3-VL-235B-A22B-Instruct"),
-    ("huggingchat-qwen3-vl-32b", "huggingchat", "Qwen/Qwen3-VL-32B-Instruct"),
-    ("huggingchat-qwen3-vl-30b", "huggingchat", "Qwen/Qwen3-VL-30B-A3B-Instruct"),
-    ("huggingchat-qwen3-vl-8b", "huggingchat", "Qwen/Qwen3-VL-8B-Instruct"),
-    ("huggingchat-qwen3-4b", "huggingchat", "Qwen/Qwen3-4B-Instruct-2507"),
-    ("huggingchat-qwen2.5-vl-72b", "huggingchat", "Qwen/Qwen2.5-VL-72B-Instruct"),
-    ("huggingchat-qwen2.5-vl-32b", "huggingchat", "Qwen/Qwen2.5-VL-32B-Instruct"),
-    ("huggingchat-qwen2.5-vl-7b", "huggingchat", "Qwen/Qwen2.5-VL-7B-Instruct"),
-    ("huggingchat-qwen2.5-coder-32b", "huggingchat", "Qwen/Qwen2.5-Coder-32B-Instruct"),
-    ("huggingchat-qwen2.5-coder-7b", "huggingchat", "Qwen/Qwen2.5-Coder-7B-Instruct"),
-    ("huggingchat-qwen2.5-coder-3b", "huggingchat", "Qwen/Qwen2.5-Coder-3B-Instruct"),
-    ("huggingchat-qwq-32b", "huggingchat", "Qwen/QwQ-32B"),
-    ("huggingchat-deepseek-r1-distill-qwen-32b", "huggingchat", "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B"),
-    ("huggingchat-deepseek-r1-distill-qwen-7b", "huggingchat", "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B"),
-    ("huggingchat-deepseek-r1-distill-llama-70b", "huggingchat", "deepseek-ai/DeepSeek-R1-Distill-Llama-70B"),
-    ("huggingchat-deepseek-r1-distill-llama-8b", "huggingchat", "deepseek-ai/DeepSeek-R1-Distill-Llama-8B"),
-    ("huggingchat-gemma-3-27b", "huggingchat", "google/gemma-3-27b-it"),
-    ("huggingchat-mistral-7b", "huggingchat", "mistralai/Mistral-7B-Instruct-v0.2"),
-    ("huggingchat-cohere-command-r", "huggingchat", "CohereLabs/c4ai-command-r-08-2024"),
-    ("huggingchat-cohere-command-a", "huggingchat", "CohereLabs/c4ai-command-a-03-2025"),
-    ("huggingchat-olmo-3-32b", "huggingchat", "allenai/Olmo-3.1-32B-Instruct"),
-    ("huggingchat-olmo-3-7b", "huggingchat", "allenai/Olmo-3-7B-Instruct"),
-    ("huggingchat-olmo-3-7b-think", "huggingchat", "allenai/Olmo-3-7B-Think"),
-    ("huggingchat-saol10k-l3-70b", "huggingchat", "Sao10K/L3-70B-Euryale-v2.1"),
-    ("huggingchat-saol10k-l3-8b", "huggingchat", "Sao10K/L3-8B-Stheno-v3.2"),
-    ("huggingchat-wizardlm-2-8x22b", "huggingchat", "alpindale/WizardLM-2-8x22B"),
-    ("huggingchat-cogito-671b", "huggingchat", "deepcogito/cogito-671b-v2.1"),
-    ("huggingchat-gpt-oss-120b", "huggingchat", "openai/gpt-oss-120b"),
-    ("huggingchat-gpt-oss-20b", "huggingchat", "openai/gpt-oss-20b"),
-    ("huggingchat-minimax-m1-80k", "huggingchat", "MiniMaxAI/MiniMax-M1-80k"),
-    ("huggingchat-zai-autoglm-phone-9b", "huggingchat", "zai-org/AutoGLM-Phone-9B-Multilingual"),
-    ("huggingchat-zai-glm-4.7-fp8", "huggingchat", "zai-org/GLM-4.7-FP8"),
-    ("huggingchat-zai-glm-4.6v", "huggingchat", "zai-org/GLM-4.6V"),
-    ("huggingchat-zai-glm-4.6v-fp8", "huggingchat", "zai-org/GLM-4.6V-FP8"),
-    ("huggingchat-zai-glm-4.6v-flash", "huggingchat", "zai-org/GLM-4.6V-Flash"),
-    ("huggingchat-zai-glm-4.5-air", "huggingchat", "zai-org/GLM-4.5-Air"),
-    ("huggingchat-zai-glm-4.5-air-fp8", "huggingchat", "zai-org/GLM-4.5-Air-FP8"),
-    ("huggingchat-zai-glm-4.5v", "huggingchat", "zai-org/GLM-4.5V"),
-    ("huggingchat-zai-glm-4.5v-fp8", "huggingchat", "zai-org/GLM-4.5V-FP8"),
-    ("huggingchat-zai-glm-4.6", "huggingchat", "zai-org/GLM-4.6"),
-    ("huggingchat-zai-glm-4.6-fp8", "huggingchat", "zai-org/GLM-4.6-FP8"),
-    ("huggingchat-zai-glm-4-32b", "huggingchat", "zai-org/GLM-4-32B-0414"),
-    ("huggingchat-nvidia-nemotron-nano-9b", "huggingchat", "nvidia/NVIDIA-Nemotron-Nano-9B-v2"),
-    ("huggingchat-mimo-v2-flash", "huggingchat", "XiaomiMiMo/MiMo-V2-Flash"),
-    ("huggingchat-eurollm-22b", "huggingchat", "utter-project/EuroLLM-22B-Instruct-2512"),
-    ("huggingchat-trinity-mini", "huggingchat", "arcee-ai/Trinity-Mini"),
-    ("huggingchat-apriel-15b-thinker", "huggingchat", "ServiceNow-AI/Apriel-1.6-15b-Thinker"),
-    ("huggingchat-arch-router-1.5b", "huggingchat", "katanemo/Arch-Router-1.5B"),
-    ("huggingchat-smollm3-3b", "huggingchat", "HuggingFaceTB/SmolLM3-3B"),
-    ("huggingchat-hermes-2-pro-llama-3-8b", "huggingchat", "NousResearch/Hermes-2-Pro-Llama-3-8B"),
-    ("huggingchat-aya-expanse-32b", "huggingchat", "CohereLabs/aya-expanse-32b"),
-    ("huggingchat-aya-vision-32b", "huggingchat", "CohereLabs/aya-vision-32b"),
-    ("huggingchat-gemma-sea-lion-v4-27b", "huggingchat", "aisingapore/Gemma-SEA-LION-v4-27B-IT"),
-    ("huggingchat-qwen-sea-lion-v4-32b", "huggingchat", "aisingapore/Qwen-SEA-LION-v4-32B-IT"),
-    ("huggingchat-dictalm-3.0-24b", "huggingchat", "dicta-il/DictaLM-3.0-24B-Thinking"),
-    ("huggingchat-apertus-8b", "huggingchat", "swiss-ai/Apertus-8B-Instruct-2509"),
-    ("huggingchat-swallow-70b", "huggingchat", "tokyotech-llm/Llama-3.3-Swallow-70B-Instruct-v0.4"),
-    ("huggingchat-marin-8b", "huggingchat", "marin-community/marin-8b-instruct"),
-    ("huggingchat-ernie-4.5-vl-424b", "huggingchat", "baidu/ERNIE-4.5-VL-424B-A47B-Base-PT"),
-    ("huggingchat-ernie-4.5-vl-28b", "huggingchat", "baidu/ERNIE-4.5-VL-28B-A3B-PT"),
-    ("huggingchat-ernie-4.5-300b", "huggingchat", "baidu/ERNIE-4.5-300B-A47B-Base-PT"),
-    ("huggingchat-ernie-4.5-21b", "huggingchat", "baidu/ERNIE-4.5-21B-A3B-PT"),
-    ("huggingchat-rnj-1-instruct", "huggingchat", "EssentialAI/rnj-1-instruct"),
-    ("huggingchat-l3-8b-lunaris", "huggingchat", "Sao10K/L3-8B-Lunaris-v1"),
-    
-    # Tier 5 — G4F Fallback Models
+    # Tier 3 — G4F Fallback Models
     ("g4f-gpt-3.5-turbo", "g4f", "gpt-3.5-turbo"),
     ("g4f-claude-3-haiku", "g4f", "claude-3-haiku"),
     ("g4f-mixtral-8x7b", "g4f", "mixtral-8x7b"),
@@ -162,6 +62,18 @@ POLLINATIONS_MODEL_NAMES = {
     "midijourney": "midijourney",
 }
 
+# Provider Configuration - Enable/Disable providers
+# These can be toggled via admin panel
+PROVIDERS = {
+    "g4f": {"enabled": True, "name": "G4F (Free GPT-4)", "type": "api"},
+    "zai": {"enabled": True, "name": "Z.ai (GLM-5)", "type": "api"},
+    "gemini": {"enabled": True, "name": "Google Gemini", "type": "api"},
+    "pollinations": {"enabled": True, "name": "Pollinations", "type": "api"},
+    "huggingchat": {"enabled": True, "name": "HuggingChat", "type": "browser"},
+    "copilot": {"enabled": False, "name": "Microsoft Copilot", "type": "browser"},
+    "chatgpt": {"enabled": False, "name": "ChatGPT", "type": "browser"},
+}
+
 # API Keys
 DEMO_API_KEY = "sk-kai-demo-public"
 
@@ -181,160 +93,6 @@ PROVIDER_MODELS = {
     "gemini": [
         "gemini-gemini-3-flash",
     ],
-    "copilot": [
-        "copilot-gpt-4",
-    ],
-    "huggingchat": [
-        # Top Tier
-        "huggingchat-omni",
-        "huggingchat-llama-3.3-70b",
-        "huggingchat-llama-4-scout",
-        "huggingchat-llama-4-maverick",
-        "huggingchat-llama-3.1-70b",
-        "huggingchat-llama-3.1-8b",
-        "huggingchat-llama-3.2-3b",
-        "huggingchat-llama-3.2-1b",
-        "huggingchat-llama-3-8b",
-        "huggingchat-llama-3-70b",
-        
-        # Kimi Models
-        "huggingchat-kimi-k2.5",
-        "huggingchat-kimi-k2",
-        "huggingchat-kimi-k2-thinking",
-        "huggingchat-kimi-k2-instruct-0905",
-        
-        # Qwen3 Models (Large)
-        "huggingchat-qwen3-235b",
-        "huggingchat-qwen3-32b",
-        "huggingchat-qwen3-14b",
-        "huggingchat-qwen3-8b",
-        "huggingchat-qwen3-4b",
-        
-        # Qwen3 Vision Models
-        "huggingchat-qwen3-vl-235b",
-        "huggingchat-qwen3-vl-32b",
-        "huggingchat-qwen3-vl-30b",
-        "huggingchat-qwen3-vl-8b",
-        
-        # Qwen2.5 Models
-        "huggingchat-qwen2.5-72b",
-        "huggingchat-qwen2.5-32b",
-        "huggingchat-qwen2.5-7b",
-        "huggingchat-qwen2.5-vl-72b",
-        "huggingchat-qwen2.5-vl-32b",
-        "huggingchat-qwen2.5-vl-7b",
-        "huggingchat-qwen2.5-coder-32b",
-        "huggingchat-qwen2.5-coder-7b",
-        "huggingchat-qwen2.5-coder-3b",
-        
-        # Qwen Coder Models
-        "huggingchat-qwen3-coder-480b",
-        "huggingchat-qwen3-coder-30b",
-        "huggingchat-qwen3-coder-next",
-        "huggingchat-qwen3-coder-next-fp8",
-        
-        # Qwen Thinking/Reasoning
-        "huggingchat-qwq-32b",
-        "huggingchat-qwen3-4b-thinking",
-        "huggingchat-qwen3-vl-235b-thinking",
-        "huggingchat-qwen3-vl-30b-thinking",
-        "huggingchat-qwen3-next-80b",
-        "huggingchat-qwen3-next-80b-thinking",
-        
-        # DeepSeek Models
-        "huggingchat-deepseek-r1",
-        "huggingchat-deepseek-v3",
-        "huggingchat-deepseek-v3.2",
-        "huggingchat-deepseek-v3.2-exp",
-        "huggingchat-deepseek-r1-0528",
-        "huggingchat-deepseek-prover-v2-671b",
-        "huggingchat-deepseek-r1-distill-qwen-32b",
-        "huggingchat-deepseek-r1-distill-qwen-7b",
-        "huggingchat-deepseek-r1-distill-qwen-1.5b",
-        "huggingchat-deepseek-r1-distill-llama-70b",
-        "huggingchat-deepseek-r1-distill-llama-8b",
-        
-        # Z.ai GLM Models
-        "huggingchat-zai-glm-5",
-        "huggingchat-zai-glm-4.7",
-        "huggingchat-zai-glm-4.7-fp8",
-        "huggingchat-zai-glm-4.7-flash",
-        "huggingchat-zai-glm-4.6v",
-        "huggingchat-zai-glm-4.6v-fp8",
-        "huggingchat-zai-glm-4.6v-flash",
-        "huggingchat-zai-glm-4.6",
-        "huggingchat-zai-glm-4.6-fp8",
-        "huggingchat-zai-glm-4.5",
-        "huggingchat-zai-glm-4.5-air",
-        "huggingchat-zai-glm-4.5-air-fp8",
-        "huggingchat-zai-glm-4.5v",
-        "huggingchat-zai-glm-4.5v-fp8",
-        "huggingchat-zai-glm-4-32b",
-        "huggingchat-zai-autoglm-phone-9b",
-        
-        # MiniMax Models
-        "huggingchat-minimax-m2.5",
-        "huggingchat-minimax-m2.1",
-        "huggingchat-minimax-m2",
-        "huggingchat-minimax-m1-80k",
-        
-        # Google Models
-        "huggingchat-gemma-3-27b",
-        "huggingchat-gemma-3n-e4b",
-        
-        # Mistral
-        "huggingchat-mistral-7b",
-        
-        # Cohere
-        "huggingchat-cohere-command-r",
-        "huggingchat-cohere-command-a",
-        "huggingchat-cohere-command-r7b",
-        "huggingchat-cohere-command-r7b-arabic",
-        "huggingchat-cohere-command-a-vision",
-        "huggingchat-cohere-command-a-reasoning",
-        "huggingchat-cohere-command-a-translate",
-        "huggingchat-cohere-aya-expanse-32b",
-        "huggingchat-cohere-aya-vision-32b",
-        
-        # Allen AI (OLMo)
-        "huggingchat-olmo-3-32b",
-        "huggingchat-olmo-3-7b",
-        "huggingchat-olmo-3-7b-think",
-        
-        # Sao10K
-        "huggingchat-saol10k-l3-70b",
-        "huggingchat-saol10k-l3-8b",
-        "huggingchat-l3-8b-lunaris",
-        
-        # Other Notable Models
-        "huggingchat-wizardlm-2-8x22b",
-        "huggingchat-cogito-671b",
-        "huggingchat-cogito-671b-fp8",
-        "huggingchat-gpt-oss-120b",
-        "huggingchat-gpt-oss-20b",
-        "huggingchat-gpt-oss-safeguard-20b",
-        "huggingchat-nvidia-nemotron-nano-9b",
-        "huggingchat-mimo-v2-flash",
-        "huggingchat-eurollm-22b",
-        "huggingchat-trinity-mini",
-        "huggingchat-apriel-15b-thinker",
-        "huggingchat-arch-router-1.5b",
-        "huggingchat-smollm3-3b",
-        "huggingchat-hermes-2-pro-llama-3-8b",
-        "huggingchat-dictalm-3.0-24b",
-        "huggingchat-apertus-8b",
-        "huggingchat-swallow-70b",
-        "huggingchat-marin-8b",
-        "huggingchat-ernie-4.5-vl-424b",
-        "huggingchat-ernie-4.5-vl-28b",
-        "huggingchat-ernie-4.5-300b",
-        "huggingchat-ernie-4.5-21b",
-        "huggingchat-rnj-1-instruct",
-        
-        # Sea Lion (Singapore)
-        "huggingchat-gemma-sea-lion-v4-27b",
-        "huggingchat-qwen-sea-lion-v4-32b",
-    ],
     "pollinations": [
         "pollinations-gpt-oss-20b",
         "pollinations-mistral-small-3.2",

engine.py

@@ -143,13 +143,35 @@ class AIEngine:
         return self._providers
 
     def get_all_models(self) -> list[ModelInfo]:
+        """Get all models from enabled providers only."""
+        from provider_state import get_provider_state_manager_sync
+        
         models = []
-        for provider in self._providers.values():
+        state_manager = get_provider_state_manager_sync()
+        enabled_providers = state_manager.get_enabled_provider_ids()
+        
+        for provider_id, provider in self._providers.items():
+            # Only include models from enabled providers
+            if provider_id not in enabled_providers:
+                continue
+                
             for model_name in provider.get_available_models():
                 models.append(
                     ModelInfo(model=model_name, provider=provider.name)
                 )
         return models
+    
+    def get_enabled_providers(self) -> dict[str, BaseProvider]:
+        """Get only enabled providers."""
+        from provider_state import get_provider_state_manager_sync
+        
+        state_manager = get_provider_state_manager_sync()
+        enabled_ids = state_manager.get_enabled_provider_ids()
+        
+        return {
+            k: v for k, v in self._providers.items()
+            if k in enabled_ids
+        }
 
     def _get_score(self, key: str) -> float:
         """
@@ -343,18 +365,40 @@ class AIEngine:
     ) -> dict:
         """
         Send a chat message with adaptive fallback.
+        Only uses enabled providers.
         """
+        from provider_state import get_provider_state_manager_sync
+        
+        # Get enabled providers
+        state_manager = get_provider_state_manager_sync()
+        enabled_providers = state_manager.get_enabled_provider_ids()
+        
+        # Build valid sets from enabled providers only
+        valid_enabled_providers = set(self._providers.keys()) & set(enabled_providers)
+        
+        # Build valid models from enabled providers only
+        valid_enabled_friendly_models = set()
+        valid_enabled_provider_models = set()
+        for fn, pn, pid in MODEL_RANKING:
+            if pn in enabled_providers:
+                valid_enabled_friendly_models.add(fn)
+                valid_enabled_provider_models.add(pid)
+                valid_enabled_provider_models.add(f"{pn}/{pid}")
 
         # Strict Validation
         if model == "auto":
             model = None
 
-        if provider != "auto" and provider not in self._valid_providers:
-            raise ValueError(f"Unknown provider '{provider}'. Available: {list(self._valid_providers)}")
+        if provider != "auto":
+            if provider not in valid_enabled_providers:
+                if provider in self._providers:
+                    raise ValueError(f"Provider '{provider}' is currently disabled.")
+                else:
+                    raise ValueError(f"Unknown provider '{provider}'. Available: {list(valid_enabled_providers)}")
             
         if model:
-            # Check if model is a known friendly name OR a valid provider model ID
-            is_valid = (model in self._valid_friendly_models) or (model in self._valid_provider_models)
+            # Check if model is a known friendly name OR a valid provider model ID (from enabled providers only)
+            is_valid = (model in valid_enabled_friendly_models) or (model in valid_enabled_provider_models)
             if not is_valid:
                 # Also check strict provider/model combos if provider is set
                 if provider != "auto":
@@ -402,10 +446,14 @@ class AIEngine:
                 
             # STRICT MODE: Specific Provider + Any Model
             # Walk this provider's models (sorted by score for this provider)
+            # Only include if provider is enabled
+            if provider not in enabled_providers:
+                raise ValueError(f"Provider '{provider}' is currently disabled.")
+                
             provider_entries = [
                 (fn, pn, pid)
                 for fn, pn, pid in MODEL_RANKING
-                if pn == provider
+                if pn == provider and pn in enabled_providers
             ]
             provider_entries.sort(
                 key=lambda x: self._get_score(f"{x[1]}/{x[2]}"),
@@ -437,15 +485,15 @@ class AIEngine:
             # 1. Identify candidates (provider, model_id)
             candidates = []
             
-            # Is it a friendly name?
+            # Is it a friendly name? (Only from enabled providers)
             for fn, pn, pid in MODEL_RANKING:
-                if fn == model:
+                if fn == model and pn in enabled_providers:
                     candidates.append((pn, pid))
             
-            # If no friendly match, maybe it's a direct ID?
+            # If no friendly match, maybe it's a direct ID? (Only from enabled providers)
             if not candidates:
                  for prov_name, prov in self._providers.items():
-                     if model in prov.get_available_models():
+                     if prov_name in enabled_providers and model in prov.get_available_models():
                          candidates.append((prov_name, model))
             
             if not candidates:
@@ -474,8 +522,17 @@ class AIEngine:
             raise ValueError(f"Strict Mode: Model '{model}' failed on available providers: {errors}")
 
         # Case 3: Global Adaptive Fallback
-        # Use the PERSISTENTLY SORTED ranking
-        adaptive_ranking = self._get_sorted_ranking()
+        # Use the PERSISTENTLY SORTED ranking (filtered to enabled providers only)
+        full_adaptive_ranking = self._get_sorted_ranking()
+        
+        # Filter to only enabled providers
+        adaptive_ranking = [
+            (fn, pn, pid) for fn, pn, pid in full_adaptive_ranking
+            if pn in enabled_providers
+        ]
+        
+        if not adaptive_ranking:
+            raise ValueError("No providers are currently enabled. Please enable at least one provider.")
         
         # === "FALLEN GIANT" EXPLORATION (10% Chance) ===
         # Goal: Give "Better" models a "Fair Chance" if they are currently failing.
@@ -485,7 +542,7 @@ class AIEngine:
             # 1. Identify "Tier 1" models (The Giants)
             # These are the first 5 models in the static configuration.
             # We assume the config is ordered by "Intrinsic Quality".
-            tier1_models = MODEL_RANKING[:5]
+            tier1_models = [m for m in MODEL_RANKING[:5] if m[1] in enabled_providers]
             tier1_keys = {f"{m[1]}/{m[2]}" for m in tier1_models}
             
             # 2. Find a Giant that has fallen (is not in the top 3 of current ranking)

proxy_manager.py

@@ -1,15 +1,13 @@
 """
-Free Proxy Manager for Browser Portals
---------------------------------------
-Fetches and manages free proxy servers for ChatGPT and Copilot.
-Automatically tests proxies and keeps ONLY working ones.
+Proxy Manager for Browser Portals
+---------------------------------
+Supports custom IP proxy configuration for the entire container.
 """
 
 import asyncio
 import aiohttp
-import random
 import logging
-from typing import Optional, List, Dict
+from typing import Optional, Dict
 from dataclasses import dataclass
 from datetime import datetime
 
@@ -20,7 +18,7 @@ class Proxy:
     """Represents a proxy server."""
     ip: str
     port: int
-    country: str
+    country: str = "Custom"
     protocol: str = "http"
     last_tested: Optional[datetime] = None
     is_working: bool = False
@@ -34,233 +32,125 @@ class Proxy:
         return {
             "server": f"{self.protocol}://{self.ip}:{self.port}",
         }
-    
-    def __hash__(self):
-        return hash((self.ip, self.port))
-    
-    def __eq__(self, other):
-        if isinstance(other, Proxy):
-            return self.ip == other.ip and self.port == other.port
-        return False
 
 
-class FreeProxyManager:
-    """Manages free proxy servers - keeps ONLY working ones."""
+class ProxyManager:
+    """Manages proxy configuration - primarily for custom IP."""
     
     def __init__(self):
-        self.working_proxies: List[Proxy] = []  # ONLY working proxies stored here
-        self.current_proxy_index: int = 0
-        self.current_proxy: Optional[Proxy] = None
+        self.custom_proxy: Optional[Proxy] = None
+        self._proxy_str: Optional[str] = None
         
-    async def fetch_and_filter_proxies(self, max_test: int = 20) -> List[Proxy]:
+    def set_custom_proxy(self, proxy_str: str) -> bool:
         """
-        Fetch proxies and test them, keeping ONLY working ones.
-        Returns list of verified working proxies.
+        Set a custom proxy from string format: ip:port or protocol://ip:port
+        Examples: 192.168.1.1:8080, http://proxy.example.com:3128
         """
-        logger.info("🔍 Fetching fresh proxies...")
-        
-        # Fetch from multiple sources
-        all_proxies = await self._fetch_from_sources()
-        
-        if not all_proxies:
-            logger.error("❌ No proxies fetched from any source")
-            return []
-        
-        logger.info(f"📊 Fetched {len(all_proxies)} total proxies, testing up to {max_test}...")
-        
-        # Shuffle for variety
-        random.shuffle(all_proxies)
-        
-        # Test proxies and collect working ones
-        working = []
-        tested = 0
-        
-        for proxy in all_proxies:
-            if tested >= max_test:
-                break
-                
-            tested += 1
-            logger.info(f"🧪 Testing proxy {tested}/{max_test}: {proxy.ip}:{proxy.port}")
-            
-            if await self._test_proxy_quick(proxy):
-                working.append(proxy)
-                logger.info(f"✅ WORKING! ({proxy.response_time:.2f}s) - Total working: {len(working)}")
-                
-                # Stop once we have enough working proxies
-                if len(working) >= 5:
-                    logger.info("✨ Found 5 working proxies, stopping tests")
-                    break
-            else:
-                logger.debug(f"❌ Dead proxy: {proxy.ip}:{proxy.port}")
-        
-        # REPLACE the list with ONLY working proxies
-        self.working_proxies = working
-        self.current_proxy_index = 0
-        
-        if working:
-            self.current_proxy = working[0]
-            logger.info(f"🎯 Kept {len(working)} WORKING proxies out of {tested} tested")
-        else:
-            self.current_proxy = None
-            logger.warning("⚠️ No working proxies found!")
-        
-        return working
-    
-    async def _fetch_from_sources(self) -> List[Proxy]:
-        """Fetch proxies from multiple free sources."""
-        proxies = []
-        
-        # Source 1: Free proxy list (HTTP)
-        try:
-            async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=15)) as session:
-                async with session.get(
-                    "https://raw.githubusercontent.com/TheSpeedX/PROXY-List/master/http.txt"
-                ) as response:
-                    if response.status == 200:
-                        text = await response.text()
-                        lines = text.strip().split('\n')
-                        for line in lines[:100]:  # Limit to first 100
-                            if ':' in line:
-                                parts = line.strip().split(':')
-                                if len(parts) >= 2:
-                                    try:
-                                        proxy = Proxy(
-                                            ip=parts[0],
-                                            port=int(parts[1]),
-                                            country='Unknown',
-                                            protocol='http'
-                                        )
-                                        proxies.append(proxy)
-                                    except:
-                                        pass
-                        logger.info(f"✅ Source 1: Got {len(proxies)} proxies")
-        except Exception as e:
-            logger.warning(f"❌ Source 1 failed: {e}")
-        
-        # Source 2: Alternative proxy list
         try:
-            async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=15)) as session:
-                async with session.get(
-                    "https://raw.githubusercontent.com/clarketm/proxy-list/master/proxy-list-raw.txt"
-                ) as response:
-                    if response.status == 200:
-                        text = await response.text()
-                        lines = text.strip().split('\n')
-                        new_count = 0
-                        for line in lines[:100]:
-                            if ':' in line:
-                                parts = line.strip().split(':')
-                                if len(parts) >= 2:
-                                    try:
-                                        proxy = Proxy(
-                                            ip=parts[0],
-                                            port=int(parts[1]),
-                                            country='Unknown',
-                                            protocol='http'
-                                        )
-                                        if proxy not in proxies:
-                                            proxies.append(proxy)
-                                            new_count += 1
-                                    except:
-                                        pass
-                        logger.info(f"✅ Source 2: Got {new_count} new proxies")
-        except Exception as e:
-            logger.warning(f"❌ Source 2 failed: {e}")
-        
-        # Source 3:geonode free proxies API
-        try:
-            url = "https://proxylist.geonode.com/api/proxy-list?limit=100&page=1&sort_by=lastChecked&sort_type=desc&protocols=http"
-            async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=15)) as session:
-                async with session.get(url) as response:
-                    if response.status == 200:
-                        data = await response.json()
-                        new_count = 0
-                        for item in data.get('data', []):
-                            try:
-                                proxy = Proxy(
-                                    ip=item['ip'],
-                                    port=int(item['port']),
-                                    country=item.get('country', 'Unknown'),
-                                    protocol='http'
-                                )
-                                if proxy not in proxies:
-                                    proxies.append(proxy)
-                                    new_count += 1
-                            except:
-                                pass
-                        logger.info(f"✅ Source 3: Got {new_count} new proxies")
+            proxy_str = proxy_str.strip()
+            
+            # Parse protocol if provided
+            protocol = "http"
+            if "://" in proxy_str:
+                protocol, proxy_str = proxy_str.split("://", 1)
+            
+            # Parse IP and port
+            if ":" not in proxy_str:
+                raise ValueError("Proxy must include port (e.g., ip:port)")
+            
+            parts = proxy_str.rsplit(":", 1)
+            ip = parts[0]
+            port = int(parts[1])
+            
+            self.custom_proxy = Proxy(
+                ip=ip,
+                port=port,
+                protocol=protocol,
+                is_working=True,  # Assume working until tested
+                last_tested=datetime.now()
+            )
+            self._proxy_str = f"{protocol}://{ip}:{port}"
+            
+            logger.info(f"✅ Custom proxy set: {self._proxy_str}")
+            return True
+            
         except Exception as e:
-            logger.warning(f"❌ Source 3 failed: {e}")
-        
-        # Remove duplicates
-        unique_proxies = list({(p.ip, p.port): p for p in proxies}.values())
-        logger.info(f"📦 Total unique proxies: {len(unique_proxies)}")
-        
-        return unique_proxies
+            logger.error(f"❌ Failed to set custom proxy: {e}")
+            return False
+    
+    def clear_proxy(self):
+        """Clear the custom proxy."""
+        self.custom_proxy = None
+        self._proxy_str = None
+        logger.info("🗑️ Custom proxy cleared")
+    
+    def get_current_proxy(self) -> Optional[Proxy]:
+        """Get the current custom proxy."""
+        return self.custom_proxy
+    
+    def get_proxy_string(self) -> Optional[str]:
+        """Get the proxy string for environment variables."""
+        return self._proxy_str
     
-    async def _test_proxy_quick(self, proxy: Proxy) -> bool:
-        """Quick test if proxy is working (5 second timeout)."""
+    async def test_proxy(self, proxy: Optional[Proxy] = None) -> bool:
+        """Test if a proxy is working."""
+        test_proxy = proxy or self.custom_proxy
+        if not test_proxy:
+            return False
+        
         try:
-            timeout = aiohttp.ClientTimeout(total=5)  # Quick 5 second test
+            timeout = aiohttp.ClientTimeout(total=10)
             
             async with aiohttp.ClientSession(timeout=timeout) as session:
                 start = asyncio.get_event_loop().time()
                 
-                # Test with a simple, fast endpoint
                 async with session.get(
                     "http://httpbin.org/ip",
-                    proxy=f"http://{proxy.ip}:{proxy.port}",
+                    proxy=f"{test_proxy.protocol}://{test_proxy.ip}:{test_proxy.port}",
                     ssl=False
                 ) as response:
                     elapsed = asyncio.get_event_loop().time() - start
                     
                     if response.status == 200:
-                        proxy.is_working = True
-                        proxy.response_time = elapsed
-                        proxy.last_tested = datetime.now()
+                        test_proxy.is_working = True
+                        test_proxy.response_time = elapsed
+                        test_proxy.last_tested = datetime.now()
+                        logger.info(f"✅ Proxy test passed: {elapsed:.2f}s")
                         return True
                     return False
                         
         except Exception as e:
-            proxy.is_working = False
+            logger.warning(f"❌ Proxy test failed: {e}")
+            test_proxy.is_working = False
             return False
     
-    def get_next_working_proxy(self) -> Optional[Proxy]:
-        """Get next working proxy from rotation."""
-        if not self.working_proxies:
-            logger.warning("No working proxies available!")
-            return None
-        
-        # Move to next proxy
-        self.current_proxy_index = (self.current_proxy_index + 1) % len(self.working_proxies)
-        self.current_proxy = self.working_proxies[self.current_proxy_index]
+    def get_status(self) -> Dict:
+        """Get proxy status."""
+        if not self.custom_proxy:
+            return {
+                "enabled": False,
+                "proxy": None,
+                "message": "No custom proxy configured"
+            }
         
-        logger.info(f"🔄 Rotated to proxy {self.current_proxy_index + 1}/{len(self.working_proxies)}: {self.current_proxy}")
-        return self.current_proxy
-    
-    def get_current_proxy(self) -> Optional[Proxy]:
-        """Get currently selected proxy."""
-        return self.current_proxy
-    
-    def get_working_proxy_list(self) -> List[Proxy]:
-        """Get list of all working proxies."""
-        return self.working_proxies.copy()
-    
-    def get_stats(self) -> Dict:
-        """Get proxy statistics."""
         return {
-            "working_proxies": len(self.working_proxies),
-            "current_proxy_index": self.current_proxy_index + 1 if self.working_proxies else 0,
-            "current_proxy": str(self.current_proxy) if self.current_proxy else None,
+            "enabled": True,
+            "proxy": str(self.custom_proxy),
+            "protocol": self.custom_proxy.protocol,
+            "ip": self.custom_proxy.ip,
+            "port": self.custom_proxy.port,
+            "is_working": self.custom_proxy.is_working,
+            "response_time": f"{self.custom_proxy.response_time:.2f}s",
+            "last_tested": self.custom_proxy.last_tested.isoformat() if self.custom_proxy.last_tested else None
         }
 
 
 # Global proxy manager instance
-_proxy_manager: Optional[FreeProxyManager] = None
+_proxy_manager: Optional[ProxyManager] = None
 
-def get_proxy_manager() -> FreeProxyManager:
+def get_proxy_manager() -> ProxyManager:
     """Get the global proxy manager instance."""
     global _proxy_manager
     if _proxy_manager is None:
-        _proxy_manager = FreeProxyManager()
+        _proxy_manager = ProxyManager()
     return _proxy_manager

static/qaz.html

@@ -1151,34 +1151,33 @@
                 <div id="portal-response" style="display: none; margin-top: 15px; padding: 15px; background: var(--surface); border-radius: 6px; border: 1px solid var(--border); white-space: pre-wrap; font-family: monospace; font-size: 13px; max-height: 200px; overflow-y: auto;"></div>
             </div>
             
-            <!-- 🌐 Proxy Rotation Controls -->
+            <!-- 🌐 Custom Proxy Configuration -->
             <div style="background: linear-gradient(135deg, rgba(139, 92, 246, 0.1), rgba(59, 130, 246, 0.1)); border: 2px solid var(--accent); border-radius: 8px; padding: 15px; margin-top: 20px;">
                 <h4 style="color: var(--accent); margin-bottom: 10px; display: flex; align-items: center;">
-                    🌐 Proxy Rotation for ChatGPT & Copilot
+                    🌐 Custom Proxy (Container-wide)
                     <span id="proxy-status-badge" style="font-size: 11px; background: var(--surface); padding: 2px 8px; border-radius: 4px; margin-left: 10px; color: var(--text-muted);">No Proxy</span>
                 </h4>
                 <p style="color: var(--text-muted); font-size: 12px; margin-bottom: 12px;">
-                    Rotate IPs to bypass restrictions. Free proxies from multiple countries.
+                    Set your own proxy IP. Format: <code>ip:port</code> or <code>http://ip:port</code>. Applies to entire container.
                 </p>
                 
-                <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(140px, 1fr)); gap: 8px; margin-bottom: 12px;">
-                    <button onclick="fetchNewProxies()" style="background: var(--accent); color: white; border: none; padding: 10px; border-radius: 6px; font-weight: 600; cursor: pointer; font-size: 12px;">
-                        🔄 Fetch New IPs
+                <div style="display: flex; gap: 10px; margin-bottom: 12px; flex-wrap: wrap;">
+                    <input type="text" id="custom-proxy-input" placeholder="e.g., 192.168.1.1:8080 or http://proxy.example.com:3128" 
+                        style="flex: 1; min-width: 250px; background: var(--surface); border: 1px solid var(--border); color: var(--text); padding: 10px; border-radius: 6px; font-family: monospace; font-size: 13px;">
+                    <button onclick="setCustomProxy()" style="background: var(--accent); color: white; border: none; padding: 10px 20px; border-radius: 6px; font-weight: 600; cursor: pointer;">
+                        💾 Set Proxy
                     </button>
-                    <button onclick="rotateProxy()" style="background: var(--warning); color: black; border: none; padding: 10px; border-radius: 6px; font-weight: 600; cursor: pointer; font-size: 12px;">
-                        🎲 Rotate IP
+                    <button onclick="clearCustomProxy()" style="background: var(--surface); color: var(--error); border: 1px solid var(--error); padding: 10px 20px; border-radius: 6px; font-weight: 600; cursor: pointer;">
+                        🗑️ Clear
                     </button>
-                    <button onclick="testProxy()" style="background: var(--success); color: white; border: none; padding: 10px; border-radius: 6px; font-weight: 600; cursor: pointer; font-size: 12px;">
-                        ✅ Test Current IP
-                    </button>
-                    <button onclick="restartWithProxy()" style="background: var(--surface); color: var(--text); border: 1px solid var(--border); padding: 10px; border-radius: 6px; font-weight: 600; cursor: pointer; font-size: 12px;">
-                        🚀 Restart with Proxy
+                    <button onclick="testCustomProxy()" style="background: var(--success); color: white; border: none; padding: 10px 20px; border-radius: 6px; font-weight: 600; cursor: pointer;">
+                        ✅ Test
                     </button>
                 </div>
                 
                 <div id="proxy-info" style="background: var(--bg); border: 1px solid var(--border); border-radius: 6px; padding: 10px; font-family: monospace; font-size: 12px; display: none;">
-                    <div><strong>Current IP:</strong> <span id="current-proxy-display">None</span></div>
-                    <div><strong>Country:</strong> <span id="proxy-country-display">-</span></div>
+                    <div><strong>Current Proxy:</strong> <span id="current-proxy-display">None</span></div>
+                    <div><strong>Status:</strong> <span id="proxy-status-display">-</span></div>
                     <div><strong>Response Time:</strong> <span id="proxy-response-display">-</span></div>
                 </div>
                 
@@ -1187,62 +1186,67 @@
         </div>
     </div>
     
+    <!-- 🔧 Provider Toggle Management Section -->
+    <div class="card" style="margin-top: 30px;">
+        <h2 style="margin-bottom: 15px;">🔧 Provider Toggle Management</h2>
+        <p style="color: var(--text-muted); margin-bottom: 20px;">
+            Enable or disable providers. Disabled providers won't appear in the dashboard or API responses.
+        </p>
+        
+        <div id="providers-list" style="display: grid; gap: 10px;">
+            <div style="text-align: center; padding: 20px; color: var(--text-muted);">Loading providers...</div>
+        </div>
+    </div>
+    
     <script>
-        // 🌐 Proxy Management Functions
-        async function fetchNewProxies() {
-            const btn = event.target;
-            const originalText = btn.textContent;
-            btn.textContent = 'Fetching...';
-            btn.disabled = true;
+        // 🌐 Custom Proxy Management Functions
+        async function setCustomProxy() {
+            const input = document.getElementById('custom-proxy-input');
+            const proxy = input.value.trim();
+            
+            if (!proxy) {
+                alert('Please enter a proxy address');
+                return;
+            }
             
             try {
-                const res = await fetch('/qaz/proxy/fetch', { method: 'POST' });
+                const res = await fetch('/qaz/proxy/set', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ proxy: proxy })
+                });
+                
                 const data = await res.json();
                 
                 if (data.status === 'success') {
-                    updateProxyDisplay(data.working_proxy, data.stats);
-                    showProxyMessage(`✅ Fetched ${data.stats.total_proxies} proxies. Working: ${data.stats.working_proxies}`);
+                    showProxyMessage(`✅ Proxy set: ${proxy}`);
+                    await loadProxyStatus();
                 } else {
                     throw new Error(data.message);
                 }
             } catch (e) {
                 showProxyMessage('❌ Error: ' + e.message);
-            } finally {
-                btn.textContent = originalText;
-                btn.disabled = false;
             }
         }
         
-        async function rotateProxy() {
-            const btn = event.target;
-            const originalText = btn.textContent;
-            btn.textContent = 'Rotating...';
-            btn.disabled = true;
+        async function clearCustomProxy() {
+            if (!confirm('Clear the custom proxy?')) return;
             
             try {
-                const res = await fetch('/qaz/proxy/rotate', { method: 'POST' });
+                const res = await fetch('/qaz/proxy/clear', { method: 'POST' });
                 const data = await res.json();
                 
                 if (data.status === 'success') {
-                    document.getElementById('proxy-status-badge').textContent = 'Active';
-                    document.getElementById('proxy-status-badge').style.color = 'var(--success)';
-                    document.getElementById('current-proxy-display').textContent = data.proxy;
-                    document.getElementById('proxy-country-display').textContent = data.country;
-                    document.getElementById('proxy-response-display').textContent = data.response_time;
-                    document.getElementById('proxy-info').style.display = 'block';
-                    showProxyMessage(`✅ Rotated to new IP: ${data.country} (${data.response_time})`);
-                } else {
-                    throw new Error(data.message);
+                    document.getElementById('custom-proxy-input').value = '';
+                    showProxyMessage('✅ Proxy cleared');
+                    await loadProxyStatus();
                 }
             } catch (e) {
                 showProxyMessage('❌ Error: ' + e.message);
-            } finally {
-                btn.textContent = originalText;
-                btn.disabled = false;
             }
         }
         
-        async function testProxy() {
+        async function testCustomProxy() {
             const btn = event.target;
             const originalText = btn.textContent;
             btn.textContent = 'Testing...';
@@ -1253,9 +1257,13 @@
                 const data = await res.json();
                 
                 if (data.is_working) {
+                    document.getElementById('proxy-status-badge').textContent = 'Working';
+                    document.getElementById('proxy-status-badge').style.color = 'var(--success)';
                     showProxyMessage(`✅ Proxy working! Response time: ${data.response_time}`);
                 } else {
-                    showProxyMessage('❌ Proxy not working. Try rotating.');
+                    document.getElementById('proxy-status-badge').textContent = 'Not Working';
+                    document.getElementById('proxy-status-badge').style.color = 'var(--error)';
+                    showProxyMessage('❌ Proxy not working. Check your settings.');
                 }
             } catch (e) {
                 showProxyMessage('❌ Error: ' + e.message);
@@ -1265,39 +1273,26 @@
             }
         }
         
-        async function restartWithProxy() {
-            if (!currentProvider) {
-                alert('Please select a provider first');
-                return;
-            }
-            
-            const btn = event.target;
-            const originalText = btn.textContent;
-            btn.textContent = 'Restarting...';
-            btn.disabled = true;
-            
+        async function loadProxyStatus() {
             try {
-                const res = await fetch(`/qaz/portal/${currentProvider}/restart-with-proxy`, { method: 'POST' });
+                const res = await fetch('/qaz/proxy/status');
                 const data = await res.json();
                 
-                if (data.status === 'success') {
-                    showProxyMessage(`✅ ${data.message}`);
-                    setTimeout(() => takePortalScreenshot(), 3000);
+                if (data.enabled) {
+                    document.getElementById('proxy-status-badge').textContent = 'Active';
+                    document.getElementById('proxy-status-badge').style.color = 'var(--success)';
+                    document.getElementById('current-proxy-display').textContent = data.proxy;
+                    document.getElementById('proxy-status-display').textContent = data.is_working ? 'Working' : 'Not Tested';
+                    document.getElementById('proxy-response-display').textContent = data.response_time || '-';
+                    document.getElementById('proxy-info').style.display = 'block';
+                    document.getElementById('custom-proxy-input').value = data.proxy;
                 } else {
-                    throw new Error(data.message);
+                    document.getElementById('proxy-status-badge').textContent = 'No Proxy';
+                    document.getElementById('proxy-status-badge').style.color = 'var(--text-muted)';
+                    document.getElementById('proxy-info').style.display = 'none';
                 }
             } catch (e) {
-                showProxyMessage('❌ Error: ' + e.message);
-            } finally {
-                btn.textContent = originalText;
-                btn.disabled = false;
-            }
-        }
-        
-        function updateProxyDisplay(proxy, stats) {
-            if (proxy) {
-                document.getElementById('current-proxy-display').textContent = proxy;
-                document.getElementById('proxy-info').style.display = 'block';
+                console.error('Failed to load proxy status:', e);
             }
         }
         
@@ -1309,6 +1304,71 @@
                 el.textContent = '';
             }, 5000);
         }
+        
+        // 🔧 Provider Toggle Functions
+        async function loadProviders() {
+            try {
+                const res = await fetch('/qaz/providers');
+                const data = await res.json();
+                
+                const container = document.getElementById('providers-list');
+                
+                if (!data.providers || data.providers.length === 0) {
+                    container.innerHTML = '<div style="text-align: center; padding: 20px; color: var(--text-muted);">No providers found</div>';
+                    return;
+                }
+                
+                container.innerHTML = data.providers.map(provider => `
+                    <div style="display: flex; justify-content: space-between; align-items: center; background: var(--surface); border: 1px solid var(--border); border-radius: 8px; padding: 15px;">
+                        <div>
+                            <div style="font-weight: 600; color: white;">${provider.name}</div>
+                            <div style="font-size: 12px; color: var(--text-muted); text-transform: uppercase;">${provider.type} • ID: ${provider.id}</div>
+                        </div>
+                        <label style="display: flex; align-items: center; cursor: pointer;">
+                            <input type="checkbox" 
+                                ${provider.enabled ? 'checked' : ''} 
+                                onchange="toggleProvider('${provider.id}', this.checked)"
+                                style="width: 50px; height: 26px; appearance: none; background: ${provider.enabled ? 'var(--success)' : 'var(--border)'}; border-radius: 13px; position: relative; cursor: pointer; transition: background 0.3s;">
+                            <span style="margin-left: 10px; font-size: 12px; color: var(--text-muted);">${provider.enabled ? 'Enabled' : 'Disabled'}</span>
+                        </label>
+                    </div>
+                `).join('');
+                
+            } catch (e) {
+                console.error('Failed to load providers:', e);
+                document.getElementById('providers-list').innerHTML = 
+                    `<div style="text-align: center; padding: 20px; color: var(--error);">Error loading providers: ${e.message}</div>`;
+            }
+        }
+        
+        async function toggleProvider(providerId, enabled) {
+            try {
+                const res = await fetch('/qaz/providers/toggle', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ provider_id: providerId, enabled: enabled })
+                });
+                
+                const data = await res.json();
+                
+                if (data.status === 'success') {
+                    // Refresh the list to show updated state
+                    await loadProviders();
+                } else {
+                    throw new Error(data.message);
+                }
+            } catch (e) {
+                alert('Error: ' + e.message);
+                // Refresh to get correct state
+                await loadProviders();
+            }
+        }
+        
+        // Initialize on page load
+        document.addEventListener('DOMContentLoaded', () => {
+            loadProviders();
+            loadProxyStatus();
+        });
     </script>
 </body>