Upload 9 files

app.py

@@ -1,4 +1,5 @@
 import gradio as gr
+import threading
 from datetime import datetime
 
 from src.config import get_api_keys, get_scan_interval_hours
@@ -13,16 +14,19 @@ class AppState:
         self.scheduler = Scheduler(task_callback=self.run_scan)
         self.scan_result = {
             "available_models": [],
-            "total_tested": 0,
-            "available_count": 0,
+            "available_free_models": [],
+            "total_available": 0,
+            "free_available": 0,
             "timestamp": None
         }
         self.last_update_time = None
+        self._initial_scan_done = False
 
     def run_scan(self):
-        result = self.model_tester.test_all_models()
+        result = self.model_tester.scan_all_models()
         self.scan_result = result
         self.last_update_time = format_timestamp()
+        self._initial_scan_done = True
 
 
 app_state = AppState()
@@ -33,8 +37,15 @@ def get_available_models():
     return "\n".join(models) if models else "No models available yet"
 
 
-def get_models_api():
+def get_available_free_models():
+    models = app_state.scan_result.get("available_free_models", [])
+    return "\n".join(models) if models else "No free models available yet"
+
+
+def get_models_api(free_only: bool = False):
     """API endpoint to get available models as JSON"""
+    if free_only:
+        return app_state.scan_result.get("available_free_models", [])
     return app_state.scan_result.get("available_models", [])
 
 
@@ -66,10 +77,10 @@ def chat(prompt: str, model: str = None):
 
 
 def get_scan_status():
-    count = app_state.scan_result.get("available_count", 0)
-    tested = app_state.scan_result.get("total_tested", 0)
+    total = app_state.scan_result.get("total_available", 0)
+    free = app_state.scan_result.get("free_available", 0)
     timestamp = app_state.last_update_time or "Never"
-    return f"Available: {count}/{tested} | Last scan: {timestamp}"
+    return f"Free: {free} | Total: {total} | Last scan: {timestamp}"
 
 
 def trigger_scan():
@@ -91,7 +102,7 @@ def get_interval_info():
 
 with gr.Blocks(title="OpenRouter Free Models Scanner") as demo:
     gr.Markdown("# OpenRouter Free Models Scanner")
-    gr.Markdown("Auto-scan available free models from OpenRouter")
+    gr.Markdown("Auto-scan all available models from OpenRouter (free priority)")
 
     with gr.Row():
         gr.Markdown(f"### API Keys: {get_api_keys_status()}")
@@ -122,26 +133,36 @@ with gr.Blocks(title="OpenRouter Free Models Scanner") as demo:
     )
 
     gr.Markdown("---")
-    gr.Markdown("## Available Models")
+    gr.Markdown("## Available Free Models (Priority)")
+
+    free_models_display = gr.Textbox(
+        value=get_available_free_models(),
+        label=f"Free Models ({len(app_state.scan_result.get('available_free_models', []))})",
+        interactive=False,
+        lines=15
+    )
+
+    gr.Markdown("## All Available Models")
 
     models_display = gr.Textbox(
         value=get_available_models(),
-        label=f"Available Models ({len(app_state.scan_result.get('available_models', []))})",
+        label=f"All Models ({len(app_state.scan_result.get('available_models', []))})",
         interactive=False,
-        lines=20
+        lines=15
     )
 
     demo.load(
         fn=lambda: (
             get_scan_status(),
+            get_available_free_models(),
             get_available_models()
         ),
-        outputs=[status_display, models_display]
+        outputs=[status_display, free_models_display, models_display]
     )
 
     app_state.scheduler.start()
 
-    gr.API(documentation=None)(get_models_api)
+    gr.API(documentation=None)(lambda free_only=False: get_models_api(free_only))
     gr.API(documentation=None)(chat)
 
 

src/model_tester.py

@@ -14,25 +14,117 @@ class ModelTester:
         self.client = OpenRouterClient()
         self.max_concurrency = config.get_max_concurrency()
         self.test_prompt = config.get_test_prompt()
-        self._cached_models: Optional[List[str]] = None
-        self._cache_time: Optional[datetime] = None
+        
+        self._all_models: List[str] = []
+        self._free_models: List[str] = []
+        self._available_models: List[str] = []
+        self._available_free_models: List[str] = []
+        self._scan_in_progress = False
+        self._last_scan_time: Optional[datetime] = None
 
-    def get_all_free_models(self) -> List[str]:
+    def refresh_model_list(self):
+        """Get latest model list from API"""
         models = self.client.get_models()
-        free_models = []
+        all_ids = []
+        free_ids = []
 
         for model in models:
             model_id = model.get("id", "")
-            if ":free" in model_id:
-                free_models.append(model_id)
+            if model_id:
+                all_ids.append(model_id)
+                if ":free" in model_id:
+                    free_ids.append(model_id)
+
+        self._all_models = all_ids
+        self._free_models = free_ids
+        return len(self._all_models), len(self._free_models)
 
-        return free_models
+    async def test_single_model_async(
+        self,
+        session: aiohttp.ClientSession,
+        model_id: str,
+        api_key: str
+    ) -> tuple[str, bool]:
+        url = "https://openrouter.ai/api/v1/chat/completions"
+        payload = {
+            "model": model_id,
+            "messages": [{"role": "user", "content": self.test_prompt}],
+            "max_tokens": 10
+        }
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
 
-    def get_cached_free_models(self, force_refresh: bool = False) -> List[str]:
-        if self._cached_models is None or force_refresh:
-            self._cached_models = self.get_all_free_models()
-            self._cache_time = datetime.now()
-        return self._cached_models
+        try:
+            timeout = aiohttp.ClientTimeout(total=config.get_request_timeout())
+            async with session.post(url, json=payload, headers=headers, timeout=timeout) as response:
+                is_success = response.status == 200
+                is_free = ":free" in model_id
+                return model_id, is_success
+        except Exception:
+            return model_id, False
+
+    async def scan_all_models_async(self):
+        """Async scan all models concurrently"""
+        if self._scan_in_progress:
+            return {"error": "Scan already in progress"}
+        
+        self._scan_in_progress = True
+        print(f"[{datetime.now()}] Starting model scan...")
+        
+        all_count, free_count = self.refresh_model_list()
+        print(f"Total models: {all_count}, Free models: {free_count}")
+        
+        api_keys = config.get_api_keys()
+        api_key = random.choice(api_keys)
+        
+        available: Set[str] = set()
+        available_free: Set[str] = set()
+        
+        async with aiohttp.ClientSession() as session:
+            semaphore = asyncio.Semaphore(self.max_concurrency)
+            
+            async def test_with_semaphore(model_id: str):
+                async with semaphore:
+                    return await self.test_single_model_async(session, model_id, api_key)
+            
+            tasks = [test_with_semaphore(m) for m in self._all_models]
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            
+            for result in results:
+                if isinstance(result, tuple):
+                    model_id, success = result
+                    cleaned = clean_model_name(model_id)
+                    if success:
+                        available.add(cleaned)
+                        if ":free" in model_id:
+                            available_free.add(cleaned)
+        
+        self._available_models = sorted(list(available))
+        self._available_free_models = sorted(list(available_free))
+        self._last_scan_time = datetime.now()
+        self._scan_in_progress = False
+        
+        print(f"Scan complete: {len(self._available_free_models)} free, {len(self._available_models)} total available")
+        
+        return {
+            "available_models": self._available_models,
+            "available_free_models": self._available_free_models,
+            "total_available": len(self._available_models),
+            "free_available": len(self._available_free_models),
+            "timestamp": self._last_scan_time.isoformat() if self._last_scan_time else None
+        }
+
+    def scan_all_models(self):
+        """Sync wrapper for scan"""
+        return asyncio.run(self.scan_all_models_async())
+
+    def get_available_models(self, free_only: bool = False) -> List[str]:
+        """Get available models list"""
+        if free_only:
+            return self._available_free_models
+        return self._available_models
 
     async def try_model_direct(
         self, 
@@ -74,38 +166,54 @@ class ModelTester:
         except Exception as e:
             return {"success": False, "model": model_id, "error": str(e), "method": "direct"}
 
-    async def try_models_from_list(
+    async def try_best_available_model(
         self,
         session: aiohttp.ClientSession,
         keyword: str,
         api_key: str
     ) -> Optional[Dict[str, Any]]:
-        free_models = self.get_cached_free_models()
+        available = self.get_available_models()
+        available_free = self.get_available_models(free_only=True)
         
-        matched = [m for m in free_models if keyword.lower() in m.lower()]
+        candidates = []
         
-        if not matched:
-            matched = free_models[:10]
-
-        for model_id in matched:
-            result = await self.try_model_direct(session, model_id, api_key)
+        if available_free:
+            if keyword:
+                matched = [m for m in available_free if keyword.lower() in m.lower()]
+                if matched:
+                    candidates.extend([(m, "free_matched") for m in matched])
+            if not candidates:
+                candidates.extend([(m, "free_random") for m in available_free[:10]])
+        
+        if available:
+            if keyword:
+                matched = [m for m in available if keyword.lower() in m.lower()]
+                if matched:
+                    candidates.extend([(m, "matched") for m in matched])
+            if not any(c[1].startswith("free") for c in candidates):
+                if available_free:
+                    candidates.extend([(m, "free_fallback") for m in available_free[:5]])
+                else:
+                    candidates.extend([(m, "random") for m in available[:10]])
+        
+        for model_id, match_type in candidates:
+            full_model = f"{model_id}:free" if ":free" not in model_id else model_id
+            result = await self.try_model_direct(session, full_model, api_key)
             if result and result.get("success"):
-                result["method"] = "list_match"
+                result["method"] = f"list_{match_type}"
                 return result
-
+        
         return {
             "success": False,
-            "model": matched[0] if matched else None,
+            "model": candidates[0][0] if candidates else None,
             "error": "No available model found",
-            "method": "list_match"
+            "method": "list_fallback"
         }
 
     async def chat_completion(self, prompt: str, model_hint: Optional[str] = None) -> Dict[str, Any]:
         api_keys = config.get_api_keys()
         api_key = random.choice(api_keys)
 
-        timeout = aiohttp.ClientTimeout(total=config.get_request_timeout())
-        
         async with aiohttp.ClientSession() as session:
             tasks = []
 
@@ -116,7 +224,7 @@ class ModelTester:
                 ))
 
             tasks.append(asyncio.create_task(
-                self.try_models_from_list(session, model_hint or "", api_key)
+                self.try_best_available_model(session, model_hint or "", api_key)
             ))
 
             done, pending = await asyncio.wait(
@@ -133,7 +241,7 @@ class ModelTester:
                     return {
                         "success": True,
                         "response": result.get("response"),
-                        "method": "direct",
+                        "method": result.get("method"),
                         "model": result.get("model")
                     }
 
@@ -143,14 +251,14 @@ class ModelTester:
                     return {
                         "success": True,
                         "response": result.get("response"),
-                        "method": "list_match",
+                        "method": result.get("method"),
                         "model": result.get("model")
                     }
                 else:
                     return {
                         "success": False,
                         "error": result.get("error", "Unknown error"),
-                        "method": "list_match"
+                        "method": result.get("method")
                     }
 
             return {
@@ -168,44 +276,5 @@ class ModelTester:
         return cleaned_name, is_available
 
     def test_all_models(self) -> Dict[str, Any]:
-        print(f"[{datetime.now()}] Starting model scan...")
-
-        free_models = self.get_cached_free_models(force_refresh=True)
-        print(f"Found {len(free_models)} free models to test")
-
-        available_models: Set[str] = set()
-        tested_count = 0
-        success_count = 0
-
-        import concurrent.futures
-        with concurrent.futures.ThreadPoolExecutor(
-            max_workers=self.max_concurrency
-        ) as executor:
-            future_to_model = {
-                executor.submit(self.test_single_model, model_id): model_id
-                for model_id in free_models
-            }
-
-            for future in concurrent.futures.as_completed(future_to_model):
-                tested_count += 1
-                try:
-                    cleaned_name, is_available = future.result()
-                    if is_available:
-                        available_models.add(cleaned_name)
-                        success_count += 1
-                        print(f"[{tested_count}/{len(free_models)}] ✓ {cleaned_name}")
-                    else:
-                        print(f"[{tested_count}/{len(free_models)}] ✗ {cleaned_name}")
-                except Exception as e:
-                    model_id = future_to_model[future]
-                    print(f"[{tested_count}/{len(free_models)}] ! {model_id}: {e}")
-
-        result = {
-            "available_models": sorted(list(available_models)),
-            "total_tested": tested_count,
-            "available_count": success_count,
-            "timestamp": datetime.now().isoformat()
-        }
-
-        print(f"Scan complete: {success_count}/{tested_count} models available")
-        return result
+        """Legacy sync method - use scan_all_models instead"""
+        return self.scan_all_models()