Update app.py

app.py

@@ -9,14 +9,14 @@ import random
 from fastapi import FastAPI, HTTPException, Request, Response
 from fastapi.middleware.cors import CORSMiddleware
 from concurrent.futures import ThreadPoolExecutor
-from curl_cffi import requests
+from curl_cffi import requests as curl_requests
 from typing import Dict, List, Optional, Tuple
 
 # =========================================================
 # 1. الإعدادات العليا (Orchestration Config)
 # =========================================================
-API_KEY = "sk-your-secret-key"
-PORT = 7860
+API_KEY = os.environ.get("API_KEY", "sk-your-secret-key")
+PORT = int(os.environ.get("PORT", 7860))
 MAX_WORKERS = 50
 VALIDATION_INTERVAL = 300
 GLOBAL_TIMEOUT = 60
@@ -30,7 +30,10 @@ MODEL_BLACKLIST = [
     "audio",
     "tts",
     "moderation",
-    "whisper"
+    "whisper",
+    "dall-e",
+    "stable-diffusion",
+    "midjourney"
 ]
 
 VALIDATION_PROMPT = [
@@ -49,15 +52,25 @@ STATE_LOCK = asyncio.Lock()
 REQUEST_LIMITER = asyncio.Semaphore(25)
 EXECUTOR = ThreadPoolExecutor(max_workers=MAX_WORKERS)
 
-app = FastAPI()
-app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
+app = FastAPI(title="Omega Orchestrator", version="2.0")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"]
+)
 
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(message)s")
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger("ORCHESTRATOR")
 
+
 def get_stealth_headers():
     return {
-        "User-Agent": f"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{random.randint(120,124)}.0.0.0 Safari/537.36",
+        "User-Agent": (
+            f"Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+            f"AppleWebKit/537.36 (KHTML, like Gecko) "
+            f"Chrome/{random.randint(120, 124)}.0.0.0 Safari/537.36"
+        ),
         "Origin": "https://g4f.space",
         "Referer": "https://g4f.space/",
         "X-Requested-With": "XMLHttpRequest",
@@ -65,45 +78,100 @@ def get_stealth_headers():
         "Content-Type": "application/json"
     }
 
+
 # =========================================================
-# 2. مستخرج المحتوى المركزي (Central Extractor)
+# 2. التحقق من المصادقة (Auth Verification) — مُصلح
+# =========================================================
+def verify_api_key(request: Request) -> bool:
+    """
+    يدعم ثلاث طرق للمصادقة:
+      1. Authorization: Bearer <key>
+      2. x-api-key: <key>
+      3. api-key: <key>
+    إذا لم يُضبط API_KEY فالوصول مفتوح.
+    """
+    if not API_KEY or API_KEY == "sk-your-secret-key":
+        return True  # No key configured → open access
+
+    auth_header = request.headers.get("Authorization", "")
+    x_api_key   = request.headers.get("x-api-key", "")
+    api_key_hdr = request.headers.get("api-key", "")
+
+    candidates = []
+
+    # Bearer token
+    if auth_header.startswith("Bearer "):
+        candidates.append(auth_header[len("Bearer "):].strip())
+
+    # x-api-key / api-key headers
+    if x_api_key:
+        candidates.append(x_api_key.strip())
+    if api_key_hdr:
+        candidates.append(api_key_hdr.strip())
+
+    return any(c == API_KEY for c in candidates)
+
+
+# =========================================================
+# 3. مستخرج المحتوى المركزي (Central Content Extractor)
 # =========================================================
 def extract_content(data) -> Optional[str]:
     if not isinstance(data, dict):
         return None
-    
-    if "response" in data: return data["response"]
-    if "content" in data: return data["content"]
-    if "text" in data: return data["text"]
-    
-    if "choices" in data and isinstance(data["choices"], list) and len(data["choices"]) > 0:
+
+    # Direct content fields
+    for field in ("response", "content", "text", "output", "result", "generated_text"):
+        if field in data and isinstance(data[field], str) and data[field].strip():
+            return data[field]
+
+    # OpenAI-style choices
+    if "choices" in data and isinstance(data["choices"], list) and data["choices"]:
         choice = data["choices"][0]
-        if "message" in choice and isinstance(choice["message"], dict) and "content" in choice["message"]:
-            return choice["message"]["content"]
-        if "text" in choice:
-            return choice["text"]
-            
+        if isinstance(choice, dict):
+            msg = choice.get("message", {})
+            if isinstance(msg, dict) and "content" in msg:
+                return msg["content"]
+            if "text" in choice and choice["text"].strip():
+                return choice["text"]
+            if "delta" in choice and "content" in choice["delta"]:
+                return choice["delta"]["content"]
+
+    # Anthropic-style message
     if "message" in data:
-        if isinstance(data["message"], dict) and "content" in data["message"]:
-            return data["message"]["content"]
-        elif isinstance(data["message"], str):
-            return data["message"]
-            
-    if "data" in data:
-        if isinstance(data["data"], dict) and "message" in data["data"]:
-            return data["data"]["message"]
-            
+        m = data["message"]
+        if isinstance(m, dict) and "content" in m:
+            c = m["content"]
+            # content can be a list of blocks
+            if isinstance(c, list):
+                texts = [b.get("text", "") for b in c if isinstance(b, dict) and b.get("type") == "text"]
+                combined = "".join(texts)
+                if combined.strip():
+                    return combined
+            elif isinstance(c, str) and c.strip():
+                return c
+        elif isinstance(m, str) and m.strip():
+            return m
+
+    # Nested data.message
+    if "data" in data and isinstance(data["data"], dict):
+        return extract_content(data["data"])
+
+    # Completion field (older APIs)
+    if "completion" in data and isinstance(data["completion"], str):
+        return data["completion"]
+
     return None
 
+
 # =========================================================
-# 3. مزودات الخدمة (Provider Classes)
+# 4. مزودات الخدمة (Provider Classes)
 # =========================================================
 class BaseProvider:
     def __init__(self, name: str, url: str):
         self.name = name
         self.url = url
         self.headers = get_stealth_headers()
-        self.aliases = {}
+        self.aliases: Dict[str, str] = {}
         self.fails = 0
         self.success = 0
         self.cooldown = 0.0
@@ -115,71 +183,114 @@ class BaseProvider:
         if total > 0:
             self.health = int((self.success / total) * 100)
 
+    # ------------------------------------------------------------------
+    # Model Discovery
+    # ------------------------------------------------------------------
     async def fetch_models(self) -> List[str]:
-        discovered_models = []
         loop = asyncio.get_event_loop()
         try:
             async with REQUEST_LIMITER:
-                discovered_models = await loop.run_in_executor(EXECUTOR, self._fetch_models_sync)
+                models = await loop.run_in_executor(EXECUTOR, self._fetch_models_sync)
+                return list(set(models))
         except Exception as e:
-            logger.debug(f"[{self.name}] Fetch models error: {e}")
-        return list(set(discovered_models))
+            logger.debug(f"[{self.name}] fetch_models error: {e}")
+            return []
 
     def _fetch_models_sync(self) -> List[str]:
-        discovered = []
-        endpoints_to_try = [f"{self.url}/models", self.url, f"{self.url}/v1/models"]
-        
-        with requests.Session() as session:
-            for endpoint in endpoints_to_try:
+        """
+        يجرب نقاط نهاية متعددة لاستخراج جميع النماذج المتاحة.
+        يدعم كافة الهياكل الشائعة: قوائم مسطّحة، قواميس، بيانات متداخلة.
+        """
+        discovered: List[str] = []
+        endpoints = [
+            f"{self.url}/v1/models",
+            f"{self.url}/models",
+            self.url,
+        ]
+
+        with curl_requests.Session() as session:
+            for endpoint in endpoints:
                 try:
-                    resp = session.get(endpoint, headers=self.headers, impersonate="chrome124", timeout=10)
-                    if resp.status_code == 200:
-                        data = resp.json()
-                        # Flat list
-                        if isinstance(data, list) and len(data) > 0 and isinstance(data[0], str):
-                            discovered.extend(data)
-                        # List of dicts
-                        elif isinstance(data, list) and len(data) > 0 and isinstance(data[0], dict) and "id" in data[0]:
-                            discovered.extend([m["id"] for m in data])
-                        # Dictionary structures
-                        elif isinstance(data, dict):
-                            if "data" in data and isinstance(data["data"], list):
-                                discovered.extend([m["id"] for m in data["data"] if "id" in m])
-                            elif "models" in data and isinstance(data["models"], list):
-                                if isinstance(data["models"][0], str):
-                                    discovered.extend(data["models"])
-                                elif isinstance(data["models"][0], dict) and "id" in data["models"][0]:
-                                    discovered.extend([m["id"] for m in data["models"]])
-                        
-                        if discovered:
-                            break
-                except:
+                    resp = session.get(
+                        endpoint,
+                        headers=self.headers,
+                        impersonate="chrome124",
+                        timeout=10
+                    )
+                    if resp.status_code != 200:
+                        continue
+                    data = resp.json()
+                    extracted = self._parse_models_response(data)
+                    if extracted:
+                        discovered.extend(extracted)
+                        break  # Found models, no need to try other endpoints
+                except Exception:
                     continue
+
         return discovered
 
+    @staticmethod
+    def _parse_models_response(data) -> List[str]:
+        """
+        يستخرج معرّفات النماذج من أي هيكل بيانات محتمل.
+        """
+        ids: List[str] = []
+
+        if isinstance(data, list):
+            for item in data:
+                if isinstance(item, str):
+                    ids.append(item)
+                elif isinstance(item, dict):
+                    for key in ("id", "name", "model", "model_id"):
+                        if key in item and isinstance(item[key], str):
+                            ids.append(item[key])
+                            break
+
+        elif isinstance(data, dict):
+            # OpenAI-style: {"data": [...]}
+            if "data" in data and isinstance(data["data"], list):
+                ids.extend(BaseProvider._parse_models_response(data["data"]))
+
+            # {"models": [...]}
+            elif "models" in data and isinstance(data["models"], list):
+                ids.extend(BaseProvider._parse_models_response(data["models"]))
+
+            # {"result": [...]} or {"results": [...]}
+            elif "result" in data and isinstance(data["result"], list):
+                ids.extend(BaseProvider._parse_models_response(data["result"]))
+            elif "results" in data and isinstance(data["results"], list):
+                ids.extend(BaseProvider._parse_models_response(data["results"]))
+
+            # Single model dict
+            elif "id" in data:
+                ids.append(data["id"])
+
+        return ids
+
+    # ------------------------------------------------------------------
+    # Validation
+    # ------------------------------------------------------------------
     async def validate_model(self, model: str) -> Tuple[bool, float]:
-        payload = {
-            "model": model,
-            "messages": VALIDATION_PROMPT
-        }
-        start_time = time.time()
+        payload = {"model": model, "messages": VALIDATION_PROMPT}
+        start = time.time()
         result = await self.attempt_request(payload)
-        latency = time.time() - start_time
-        
-        if result and result.strip().lower() == "ok":
+        latency = time.time() - start
+
+        ok = result is not None and "ok" in result.strip().lower()
+        if ok:
             self.success += 1
-            self.update_health()
             self.latency = (self.latency + latency) / 2 if self.latency > 0 else latency
-            return True, latency
         else:
             self.fails += 1
-            self.update_health()
-            return False, latency
+        self.update_health()
+        return ok, latency
 
+    # ------------------------------------------------------------------
+    # Request Handling
+    # ------------------------------------------------------------------
     async def attempt_request(self, payload: dict) -> Optional[str]:
-        # المطلوب الأول: نسخ الـ payload قبل التعديل لمنع الـ Leakage
-        payload = payload.copy()
-        
+        payload = payload.copy()  # prevent mutation leakage
+
         if time.time() < self.cooldown:
             return None
 
@@ -190,71 +301,117 @@ class BaseProvider:
             async with REQUEST_LIMITER:
                 loop = asyncio.get_event_loop()
                 content = await loop.run_in_executor(EXECUTOR, self._make_request, payload)
-                
-                if content:
-                    self.fails = 0
-                    self.success += 1
-                    self.update_health()
-                    return content
-                
-                self.fails += 1
+
+            if content:
+                self.fails = 0
+                self.success += 1
                 self.update_health()
-                if self.fails >= 3:
-                    self.cooldown = time.time() + 60
-                return None
-        except:
+                return content
+
+            self.fails += 1
+            self.update_health()
+            if self.fails >= 3:
+                self.cooldown = time.time() + 60
+            return None
+
+        except Exception:
             self.fails += 1
             self.update_health()
             return None
 
     def _make_request(self, payload: dict) -> Optional[str]:
-        with requests.Session() as session:
-            resp = session.post(self.url, headers=self.headers, json=payload, impersonate="chrome124", timeout=25)
-            if resp.status_code == 200:
-                try:
+        with curl_requests.Session() as session:
+            try:
+                resp = session.post(
+                    self.url,
+                    headers=self.headers,
+                    json=payload,
+                    impersonate="chrome124",
+                    timeout=25
+                )
+                if resp.status_code == 200:
                     data = resp.json()
                     content = extract_content(data)
-                    if content is not None:
-                        content_str = str(content)
-                        if len(content_str.strip()) > 0:
-                            return content_str
-                except:
-                    pass
+                    if content and str(content).strip():
+                        return str(content).strip()
+            except Exception:
+                pass
         return None
 
+
+# ------------------------------------------------------------------
+# Provider Definitions
+# ------------------------------------------------------------------
 class GroqProvider(BaseProvider):
     def __init__(self):
         super().__init__("Groq", "https://g4f.space/api/groq")
         self.aliases = {"gpt-4o": "llama-3-70b"}
 
+
 class GeminiProvider(BaseProvider):
     def __init__(self):
         super().__init__("Gemini", "https://g4f.space/api/gemini")
         self.aliases = {"claude-3-5-sonnet": "gemini-1.5-pro"}
 
+
 class PollinationsProvider(BaseProvider):
     def __init__(self):
         super().__init__("Pollinations", "https://g4f.space/api/pollinations")
         self.aliases = {"gpt-4o": "gpt-4"}
 
+
 class OllamaProvider(BaseProvider):
     def __init__(self):
         super().__init__("Ollama", "https://g4f.space/api/ollama")
 
+
 class PerplexityProvider(BaseProvider):
     def __init__(self):
         super().__init__("Perplexity", "https://g4f.space/api/perplexity")
 
-PROVIDER_INSTANCES = [
+
+class OpenRouterProvider(BaseProvider):
+    """
+    مزوّد إضافي: OpenRouter — يتيح الوصول إلى مئات النماذج تلقائياً.
+    """
+    def __init__(self):
+        super().__init__("OpenRouter", "https://openrouter.ai/api/v1/chat/completions")
+        self.models_url = "https://openrouter.ai/api/v1/models"
+
+    async def fetch_models(self) -> List[str]:
+        loop = asyncio.get_event_loop()
+        try:
+            async with REQUEST_LIMITER:
+                models = await loop.run_in_executor(EXECUTOR, self._fetch_openrouter_models)
+                return list(set(models))
+        except Exception as e:
+            logger.debug(f"[OpenRouter] fetch_models error: {e}")
+            return []
+
+    def _fetch_openrouter_models(self) -> List[str]:
+        with curl_requests.Session() as session:
+            try:
+                resp = session.get(self.models_url, headers=self.headers, impersonate="chrome124", timeout=10)
+                if resp.status_code == 200:
+                    data = resp.json()
+                    return self._parse_models_response(data)
+            except Exception:
+                pass
+        return []
+
+
+PROVIDER_INSTANCES: List[BaseProvider] = [
     GroqProvider(),
     GeminiProvider(),
     PollinationsProvider(),
     OllamaProvider(),
-    PerplexityProvider()
+    PerplexityProvider(),
+    OpenRouterProvider(),
 ]
 
+
 # =========================================================
-# 4. إدارة الحالة والتخزين المؤقت (State & Cache Management)
+# 5. إدارة الحالة والتخزين المؤقت
 # =========================================================
 async def load_cache():
     global WORKING_MODELS, PROVIDER_MODEL_MAP
@@ -262,175 +419,232 @@ async def load_cache():
         if os.path.exists(CACHE_FILE):
             with open(CACHE_FILE, "r", encoding="utf-8") as f:
                 data = json.load(f)
-                async with STATE_LOCK:
-                    WORKING_MODELS = data.get("WORKING_MODELS", {})
-                    PROVIDER_MODEL_MAP = data.get("PROVIDER_MODEL_MAP", {})
-            logger.info("✅ Cache loaded successfully.")
+            async with STATE_LOCK:
+                WORKING_MODELS = data.get("WORKING_MODELS", {})
+                PROVIDER_MODEL_MAP = data.get("PROVIDER_MODEL_MAP", {})
+            logger.info(f"✅ Cache loaded — {len(WORKING_MODELS)} models.")
     except Exception as e:
         logger.error(f"⚠️ Cache load error: {e}")
 
+
 async def save_cache():
     try:
         async with STATE_LOCK:
-            data = {
-                "WORKING_MODELS": WORKING_MODELS,
-                "PROVIDER_MODEL_MAP": PROVIDER_MODEL_MAP
+            snapshot = {
+                "WORKING_MODELS": dict(WORKING_MODELS),
+                "PROVIDER_MODEL_MAP": dict(PROVIDER_MODEL_MAP)
             }
         with open(CACHE_FILE, "w", encoding="utf-8") as f:
-            json.dump(data, f, indent=4, ensure_ascii=False)
+            json.dump(snapshot, f, indent=4, ensure_ascii=False)
+        logger.info("💾 Cache saved.")
     except Exception as e:
         logger.error(f"⚠️ Cache save error: {e}")
 
+
 # =========================================================
-# 5. محرك الاستكشاف والتحقق (Discovery & Validation Engine)
+# 6. محرك الاستكشاف والتحقق
 # =========================================================
 async def discovery_engine():
     await load_cache()
+
     while True:
-        logger.info("📡 Running Validated Discovery Cycle with Auto-Import...")
-        
-        fresh_provider_map = {}
-        fresh_working_models = {}
-        
-        for provider in PROVIDER_INSTANCES:
-            # 1. Discover
-            discovered_models = await provider.fetch_models()
-            clean_models = []
-            
-            # 2. Validate ALL imported models
-            for model in discovered_models:
-                if any(x in model.lower() for x in MODEL_BLACKLIST):
-                    continue
-                
-                is_valid, latency = await provider.validate_model(model)
+        logger.info("📡 Starting validated discovery cycle …")
+
+        fresh_provider_map: Dict[str, List[str]] = {}
+        fresh_working_models: Dict[str, dict] = {}
+
+        # Run provider discovery concurrently
+        tasks = {provider: asyncio.create_task(provider.fetch_models()) for provider in PROVIDER_INSTANCES}
+
+        for provider, task in tasks.items():
+            discovered = await task
+            clean_models: List[str] = []
+
+            # Filter & validate
+            validation_tasks = []
+            filtered = [
+                m for m in discovered
+                if not any(bl in m.lower() for bl in MODEL_BLACKLIST)
+            ]
+
+            logger.info(f"[{provider.name}] Discovered {len(filtered)} candidate models — validating …")
+
+            for model in filtered:
+                validation_tasks.append((model, asyncio.create_task(provider.validate_model(model))))
+
+            for model, vtask in validation_tasks:
+                try:
+                    is_valid, latency = await vtask
+                except Exception:
+                    is_valid, latency = False, 0.0
+
                 if is_valid:
                     clean_models.append(model)
-                    
-                    # 3. Score & Capability Registry Build
+
                     if model not in fresh_working_models:
                         fresh_working_models[model] = {
                             "providers": [],
                             "latency": latency,
                             "health": provider.health,
-                            "aliases": {}
+                            "aliases": provider.aliases
                         }
-                    
-                    fresh_working_models[model]["providers"].append(provider.url)
-                    curr_lat = fresh_working_models[model]["latency"]
-                    fresh_working_models[model]["latency"] = (curr_lat + latency) / 2
-                    fresh_working_models[model]["health"] = (fresh_working_models[model]["health"] + provider.health) // 2
-                    
+
+                    info = fresh_working_models[model]
+                    if provider.url not in info["providers"]:
+                        info["providers"].append(provider.url)
+                    info["latency"] = (info["latency"] + latency) / 2
+                    info["health"] = (info["health"] + provider.health) // 2
+
             fresh_provider_map[provider.url] = clean_models
-            logger.info(f"🔄 Provider {provider.name}: {len(clean_models)} clean models validated.")
-            
-        # 4. Atomic Publish
+            logger.info(f"✅ [{provider.name}] {len(clean_models)} valid models.")
+
+        # Atomic publish
         async with STATE_LOCK:
             global PROVIDER_MODEL_MAP, WORKING_MODELS
             PROVIDER_MODEL_MAP = fresh_provider_map
             WORKING_MODELS = fresh_working_models
-            
-        # 5. Cache
+
         await save_cache()
-        logger.info(f"✅ Orchestrator Ready. Active Models Count: {len(WORKING_MODELS.keys())}")
+        logger.info(f"🚀 Orchestrator ready — {len(WORKING_MODELS)} active models.")
         await asyncio.sleep(VALIDATION_INTERVAL)
 
+
 # =========================================================
-# 6. المعالج المركزي (The Orchestration Handler)
+# 7. المعالج المركزي (Omega Handler)
 # =========================================================
 @app.on_event("startup")
-async def startup(): 
+async def startup():
     asyncio.create_task(discovery_engine())
 
-@app.api_route("/{path:path}", methods=["GET", "HEAD", "POST"])
+
+@app.api_route("/{path:path}", methods=["GET", "HEAD", "POST", "OPTIONS"])
 async def omega_handler(request: Request, path: str):
-    if request.method in ["GET", "HEAD"] and any(x in path for x in ["", "v1", "models"]):
-        if "models" in path:
+    # ---- CORS preflight ----
+    if request.method == "OPTIONS":
+        return Response(status_code=204, headers={
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+            "Access-Control-Allow-Headers": "*"
+        })
+
+    path_lower = path.lower().strip("/")
+
+    # ---- Model listing ----
+    if request.method in ("GET", "HEAD") and ("models" in path_lower or path_lower in ("", "v1", "v1/")):
+        if "models" in path_lower:
             async with STATE_LOCK:
-                display = list(WORKING_MODELS.keys()) if WORKING_MODELS else ["gpt-4o", "claude-3-5-sonnet"]
-            return {"object": "list", "data": [{"id": m, "object": "model", "created": int(time.time()), "owned_by": "omega"} for m in display]}
+                model_ids = list(WORKING_MODELS.keys()) if WORKING_MODELS else ["gpt-4o", "claude-3-5-sonnet"]
+            return {
+                "object": "list",
+                "data": [
+                    {
+                        "id": m,
+                        "object": "model",
+                        "created": int(time.time()),
+                        "owned_by": "omega-orchestrator"
+                    }
+                    for m in sorted(model_ids)
+                ]
+            }
         return Response(status_code=200)
 
-    if request.method == "POST" and any(x in path for x in ["messages", "completions"]):
-        # المطلوب الثاني: إصلاح نظام التحقق الأمني
-        auth_header = request.headers.get("Authorization", "")
-        x_api_key = request.headers.get("x-api-key", "")
-
-        token = (
-            auth_header.replace("Bearer ", "").strip()
-            if "Bearer " in auth_header
-            else x_api_key
-        )
+    # ---- Chat completions ----
+    if request.method == "POST" and any(x in path_lower for x in ("messages", "completions", "chat")):
 
-        if API_KEY and token != API_KEY:
-            raise HTTPException(status_code=401)
+        # --- Auth check (مُصلح) ---
+        if not verify_api_key(request):
+            raise HTTPException(status_code=401, detail="Unauthorized: invalid or missing API key.")
 
+        # --- Parse body ---
         try:
             body = await request.json()
-        except:
-            raise HTTPException(status_code=400, detail="Invalid JSON body")
-            
-        model = body.get("model", "gpt-4o")
+        except Exception:
+            raise HTTPException(status_code=400, detail="Invalid JSON body.")
+
+        model    = body.get("model", "gpt-4o")
         messages = body.get("messages", [])
 
-        # Smart Routing based on Capability Registry
+        if not messages:
+            raise HTTPException(status_code=400, detail="messages field is required.")
+
+        # --- Smart routing ---
         async with STATE_LOCK:
             model_info = WORKING_MODELS.get(model)
             if model_info and model_info.get("providers"):
-                target_urls = model_info["providers"].copy()
+                target_urls = list(model_info["providers"])
             else:
                 target_urls = [p.url for p in PROVIDER_INSTANCES]
 
         providers = [p for p in PROVIDER_INSTANCES if p.url in target_urls]
-        
-        # الترتيب الذكي بناءً على الفشل، الصحة، وزمن الاستجابة
+
+        # Sort: fewest fails → highest health → lowest latency
         providers.sort(key=lambda p: (p.fails, -p.health, p.latency))
 
-        reply = None
+        reply: Optional[str] = None
+
         for provider in providers:
             if time.time() < provider.cooldown:
                 continue
             reply = await provider.attempt_request(body)
-            if reply: 
+            if reply:
+                logger.info(f"✅ Served by [{provider.name}] model={model}")
                 break
 
-        # Fallback الداخلي الآمن
+        # --- Internal fallback via g4f ---
         if not reply:
             try:
                 from g4f.client import Client
                 loop = asyncio.get_event_loop()
+
                 def fallback_req():
-                    return Client().chat.completions.create(model=model, messages=messages).choices[0].message.content
+                    return (
+                        Client()
+                        .chat.completions.create(model=model, messages=messages)
+                        .choices[0].message.content
+                    )
+
                 reply = await loop.run_in_executor(EXECUTOR, fallback_req)
-            except: 
-                pass
+                logger.info("🔄 Served via g4f fallback.")
+            except Exception as e:
+                logger.warning(f"g4f fallback failed: {e}")
 
-        if not reply: 
-            raise HTTPException(status_code=502, detail="Orchestration Failed: All routes exhausted.")
+        if not reply:
+            raise HTTPException(status_code=502, detail="Orchestration Failed: all routes exhausted.")
 
-        # التوافقية الكاملة للردود
-        if "messages" in path:
+        # --- Format response ---
+        # Anthropic messages format
+        if "messages" in path_lower and "chat" not in path_lower:
             return {
-                "id": f"msg_{uuid.uuid4()}", 
-                "type": "message", 
-                "role": "assistant", 
-                "model": model, 
-                "content": [{"type": "text", "text": reply}], 
-                "stop_reason": "end_turn"
+                "id": f"msg_{uuid.uuid4().hex}",
+                "type": "message",
+                "role": "assistant",
+                "model": model,
+                "content": [{"type": "text", "text": reply}],
+                "stop_reason": "end_turn",
+                "usage": {"input_tokens": 0, "output_tokens": 0}
             }
-            
+
+        # OpenAI chat.completions format (default)
         return {
-            "id": f"chatcmpl-{uuid.uuid4()}", 
-            "object": "chat.completion", 
-            "created": int(time.time()), 
-            "model": model, 
-            "choices": [{
-                "index": 0, 
-                "message": {"role": "assistant", "content": reply}, 
-                "finish_reason": "stop"
-            }]
+            "id": f"chatcmpl-{uuid.uuid4().hex}",
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": model,
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {"role": "assistant", "content": reply},
+                    "finish_reason": "stop"
+                }
+            ],
+            "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
         }
 
     return Response(status_code=404)
 
+
+# =========================================================
+# 8. نقطة الدخول
+# =========================================================
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=PORT, log_level="info")