Upload 9 files

app.py

@@ -33,6 +33,38 @@ def get_available_models():
     return "\n".join(models) if models else "No models available yet"
 
 
+def get_models_api():
+    """API endpoint to get available models as JSON"""
+    return app_state.scan_result.get("available_models", [])
+
+
+def scan_and_get_models():
+    """Trigger scan and return models"""
+    app_state.scheduler.run_now()
+    import time
+    time.sleep(2)
+    return app_state.scan_result.get("available_models", [])
+
+
+def chat(prompt: str, model: str = None):
+    """Chat endpoint - tries direct model first, then falls back to list match"""
+    result = app_state.model_tester.chat_completion_sync(prompt, model)
+    
+    if result.get("success"):
+        return {
+            "success": True,
+            "response": result.get("response"),
+            "method": result.get("method"),
+            "model": result.get("model")
+        }
+    else:
+        return {
+            "success": False,
+            "error": result.get("error", "Unknown error"),
+            "method": result.get("method")
+        }
+
+
 def get_scan_status():
     count = app_state.scan_result.get("available_count", 0)
     tested = app_state.scan_result.get("total_tested", 0)
@@ -109,6 +141,9 @@ with gr.Blocks(title="OpenRouter Free Models Scanner") as demo:
 
     app_state.scheduler.start()
 
+    gr.API(documentation=None)(get_models_api)
+    gr.API(documentation=None)(chat)
+
 
 if __name__ == "__main__":
     demo.launch()

requirements.txt

@@ -2,3 +2,4 @@ gradio
 requests
 python-dotenv
 schedule
+aiohttp

src/model_tester.py

@@ -1,6 +1,8 @@
-import concurrent.futures
-from typing import List, Dict, Any, Set
+import asyncio
+import aiohttp
+from typing import List, Dict, Any, Optional, Set
 from datetime import datetime
+import random
 
 from .openrouter_client import OpenRouterClient
 from . import config
@@ -12,6 +14,8 @@ 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
 
     def get_all_free_models(self) -> List[str]:
         models = self.client.get_models()
@@ -24,6 +28,140 @@ class ModelTester:
 
         return free_models
 
+    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
+
+    async def try_model_direct(
+        self, 
+        session: aiohttp.ClientSession, 
+        model_id: str,
+        api_key: str
+    ) -> Optional[Dict[str, Any]]:
+        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"
+        }
+
+        try:
+            timeout = aiohttp.ClientTimeout(total=config.get_request_timeout())
+            async with session.post(url, json=payload, headers=headers, timeout=timeout) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    return {
+                        "success": True,
+                        "model": model_id,
+                        "response": data,
+                        "method": "direct"
+                    }
+                else:
+                    return {
+                        "success": False,
+                        "model": model_id,
+                        "error": f"HTTP {response.status}",
+                        "method": "direct"
+                    }
+        except asyncio.TimeoutError:
+            return {"success": False, "model": model_id, "error": "timeout", "method": "direct"}
+        except Exception as e:
+            return {"success": False, "model": model_id, "error": str(e), "method": "direct"}
+
+    async def try_models_from_list(
+        self,
+        session: aiohttp.ClientSession,
+        keyword: str,
+        api_key: str
+    ) -> Optional[Dict[str, Any]]:
+        free_models = self.get_cached_free_models()
+        
+        matched = [m for m in free_models if keyword.lower() in m.lower()]
+        
+        if not matched:
+            matched = free_models[:10]
+
+        for model_id in matched:
+            result = await self.try_model_direct(session, model_id, api_key)
+            if result and result.get("success"):
+                result["method"] = "list_match"
+                return result
+
+        return {
+            "success": False,
+            "model": matched[0] if matched else None,
+            "error": "No available model found",
+            "method": "list_match"
+        }
+
+    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 = []
+
+            if model_hint:
+                full_model = f"{model_hint}:free" if ":free" not in model_hint else model_hint
+                tasks.append(asyncio.create_task(
+                    self.try_model_direct(session, full_model, api_key)
+                ))
+
+            tasks.append(asyncio.create_task(
+                self.try_models_from_list(session, model_hint or "", api_key)
+            ))
+
+            done, pending = await asyncio.wait(
+                tasks,
+                return_when=asyncio.FIRST_COMPLETED
+            )
+
+            for task in pending:
+                task.cancel()
+
+            if tasks[0] in done:
+                result = tasks[0].result()
+                if result and result.get("success"):
+                    return {
+                        "success": True,
+                        "response": result.get("response"),
+                        "method": "direct",
+                        "model": result.get("model")
+                    }
+
+            if tasks[1] in done:
+                result = tasks[1].result()
+                if result and result.get("success"):
+                    return {
+                        "success": True,
+                        "response": result.get("response"),
+                        "method": "list_match",
+                        "model": result.get("model")
+                    }
+                else:
+                    return {
+                        "success": False,
+                        "error": result.get("error", "Unknown error"),
+                        "method": "list_match"
+                    }
+
+            return {
+                "success": False,
+                "error": "Both methods failed",
+                "method": "both_failed"
+            }
+
+    def chat_completion_sync(self, prompt: str, model_hint: Optional[str] = None) -> Dict[str, Any]:
+        return asyncio.run(self.chat_completion(prompt, model_hint))
+
     def test_single_model(self, model_id: str) -> tuple[str, bool]:
         is_available = self.client.test_model(model_id, self.test_prompt)
         cleaned_name = clean_model_name(model_id)
@@ -32,13 +170,14 @@ class ModelTester:
     def test_all_models(self) -> Dict[str, Any]:
         print(f"[{datetime.now()}] Starting model scan...")
 
-        free_models = self.get_all_free_models()
+        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: