Update app.py

app.py

@@ -10,286 +10,245 @@ from fastapi import FastAPI, HTTPException, Request, Response
 from fastapi.middleware.cors import CORSMiddleware
 from concurrent.futures import ThreadPoolExecutor
 from curl_cffi import requests as curl_requests
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, List, Optional
 
 # =========================================================
-# 1. الإعدادات العليا (Orchestration Config)
+# 1. الإعدادات
 # =========================================================
-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
-CACHE_FILE = "models_cache.json"
+API_KEY          = os.environ.get("API_KEY", "sk-your-secret-key")
+PORT             = int(os.environ.get("PORT", 7860))
+MAX_WORKERS      = 50
+REFRESH_INTERVAL = 300          # ثواني بين دورات الاستكشاف
+CACHE_FILE       = "models_cache.json"
 
+# نماذج غير نصية — يُستبعد استيرادها
 MODEL_BLACKLIST = [
-    "embed",
-    "embedding",
-    "vision",
-    "image",
-    "audio",
-    "tts",
+    "embed", "embedding",
+    "image", "vision",
+    "audio", "tts", "whisper",
     "moderation",
-    "whisper",
-    "dall-e",
-    "stable-diffusion",
-    "midjourney"
+    "dall-e", "stable-diffusion", "midjourney",
 ]
 
-VALIDATION_PROMPT = [
-    {
-        "role": "user",
-        "content": "Reply only with: OK"
-    }
-]
-
-# Capability Registry
-WORKING_MODELS: Dict[str, dict] = {}
-PROVIDER_MODEL_MAP: Dict[str, List[str]] = {}
+# ===================== الحالة العامة =====================
+WORKING_MODELS: Dict[str, dict] = {}       # { model_id: {providers, latency, health} }
+PROVIDER_MODEL_MAP: Dict[str, List[str]] = {}  # { chat_url: [model_id, ...] }
 
-# Atomic State & Concurrency Control
-STATE_LOCK = asyncio.Lock()
-REQUEST_LIMITER = asyncio.Semaphore(25)
-EXECUTOR = ThreadPoolExecutor(max_workers=MAX_WORKERS)
+STATE_LOCK      = asyncio.Lock()
+REQUEST_LIMITER = asyncio.Semaphore(30)
+EXECUTOR        = ThreadPoolExecutor(max_workers=MAX_WORKERS)
 
-app = FastAPI(title="Omega Orchestrator", version="2.0")
+app = FastAPI(title="Omega Orchestrator", version="3.0")
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
     allow_methods=["*"],
-    allow_headers=["*"]
+    allow_headers=["*"],
 )
 
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
-logger = logging.getLogger("ORCHESTRATOR")
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+logger = logging.getLogger("OMEGA")
 
 
-def get_stealth_headers():
+# =========================================================
+# 2. مساعدات
+# =========================================================
+def stealth_headers() -> dict:
     return {
         "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"
+            f"Chrome/{random.randint(120, 126)}.0.0.0 Safari/537.36"
         ),
-        "Origin": "https://g4f.space",
-        "Referer": "https://g4f.space/",
+        "Origin":           "https://g4f.space",
+        "Referer":          "https://g4f.space/",
         "X-Requested-With": "XMLHttpRequest",
-        "Accept": "application/json",
-        "Content-Type": "application/json"
+        "Accept":           "application/json",
+        "Content-Type":     "application/json",
     }
 
 
-# =========================================================
-# 2. التحقق من المصادقة (Auth Verification) — مُصلح
-# =========================================================
+def is_blacklisted(model_id: str) -> bool:
+    low = model_id.lower()
+    return any(b in low for b in MODEL_BLACKLIST)
+
+
 def verify_api_key(request: Request) -> bool:
     """
-    يدعم ثلاث طرق للمصادقة:
-      1. Authorization: Bearer <key>
-      2. x-api-key: <key>
-      3. api-key: <key>
-    إذا لم يُضبط API_KEY فالوصول مفتوح.
+    يقبل المفتاح من ثلاث طرق:
+      - Authorization: Bearer <key>
+      - x-api-key: <key>
+      - api-key: <key>
+    وصول مفتوح إذا لم يُضبط API_KEY.
     """
     if not API_KEY or API_KEY == "sk-your-secret-key":
-        return True  # No key configured → open access
+        return True
 
-    auth_header = request.headers.get("Authorization", "")
-    x_api_key   = request.headers.get("x-api-key", "")
-    api_key_hdr = request.headers.get("api-key", "")
+    candidates: List[str] = []
 
-    candidates = []
+    auth = request.headers.get("Authorization", "")
+    if auth.startswith("Bearer "):
+        candidates.append(auth[7:].strip())
 
-    # 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())
+    for h in ("x-api-key", "api-key"):
+        v = request.headers.get(h, "").strip()
+        if v:
+            candidates.append(v)
 
     return any(c == API_KEY for c in candidates)
 
 
 # =========================================================
-# 3. مستخرج المحتوى المركزي (Central Content Extractor)
+# 3. استخراج المحتوى من أي رد JSON
 # =========================================================
 def extract_content(data) -> Optional[str]:
     if not isinstance(data, dict):
         return None
 
-    # 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 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:
-        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"]
+    for f in ("response", "content", "text", "output", "result", "generated_text", "completion"):
+        v = data.get(f)
+        if isinstance(v, str) and v.strip():
+            return v.strip()
+
+    choices = data.get("choices")
+    if isinstance(choices, list) and choices:
+        c = choices[0]
+        if isinstance(c, dict):
+            msg = c.get("message", {})
+            if isinstance(msg, dict):
+                t = msg.get("content")
+                if isinstance(t, str) and t.strip():
+                    return t.strip()
+            txt = c.get("text", "")
+            if isinstance(txt, str) and txt.strip():
+                return txt.strip()
+            delta = c.get("delta", {})
+            if isinstance(delta, dict):
+                t = delta.get("content", "")
+                if isinstance(t, str) and t.strip():
+                    return t.strip()
+
+    msg = data.get("message")
+    if isinstance(msg, dict):
+        c = msg.get("content")
+        if isinstance(c, list):
+            parts = [b.get("text", "") for b in c if isinstance(b, dict) and b.get("type") == "text"]
+            joined = "".join(parts).strip()
+            if joined:
+                return joined
+        elif isinstance(c, str) and c.strip():
+            return c.strip()
+    elif isinstance(msg, str) and msg.strip():
+        return msg.strip()
+
+    inner = data.get("data")
+    if isinstance(inner, dict):
+        return extract_content(inner)
 
     return None
 
 
 # =========================================================
-# 4. مزودات الخدمة (Provider Classes)
+# 4. كلاس المزوّد الأساسي
 # =========================================================
 class BaseProvider:
-    def __init__(self, name: str, url: str):
-        self.name = name
-        self.url = url
-        self.headers = get_stealth_headers()
+    def __init__(self, name: str, url_chat: str, url_models: str = ""):
+        self.name       = name
+        self.url_chat   = url_chat
+        self.url_models = url_models or url_chat
+        self.headers    = stealth_headers()
         self.aliases: Dict[str, str] = {}
-        self.fails = 0
-        self.success = 0
-        self.cooldown = 0.0
-        self.latency = 0.0
-        self.health = 100
-
-    def update_health(self):
+        self.fails      = 0
+        self.success    = 0
+        self.cooldown   = 0.0
+        self.latency    = 0.0
+        self.health     = 100
+
+    def _record_success(self, latency: float):
+        self.success += 1
+        self.latency = (self.latency + latency) / 2 if self.latency else latency
+        self._calc_health()
+
+    def _record_fail(self):
+        self.fails += 1
+        self._calc_health()
+        if self.fails >= 3:
+            self.cooldown = time.time() + 60
+
+    def _calc_health(self):
         total = self.success + self.fails
-        if total > 0:
-            self.health = int((self.success / total) * 100)
+        self.health = int(self.success / total * 100) if total else 100
 
-    # ------------------------------------------------------------------
-    # Model Discovery
-    # ------------------------------------------------------------------
+    # ── جلب النماذج — بدون تحقق، مباشرة من المزوّد ──────
     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_models_sync)
-                return list(set(models))
+                raw = await loop.run_in_executor(EXECUTOR, self._fetch_models_sync)
+            return [m for m in set(raw) if m and not is_blacklisted(m)]
         except Exception as e:
-            logger.debug(f"[{self.name}] fetch_models error: {e}")
+            logger.warning(f"[{self.name}] fetch_models error: {e}")
             return []
 
     def _fetch_models_sync(self) -> List[str]:
-        """
-        يجرب نقاط نهاية متعددة لاستخراج جميع النماذج المتاحة.
-        يدعم كافة الهياكل الشائعة: قوائم مسطّحة، قواميس، بيانات متداخلة.
-        """
-        discovered: List[str] = []
-        endpoints = [
-            f"{self.url}/v1/models",
-            f"{self.url}/models",
-            self.url,
-        ]
+        # نقاط النهاية المحتملة بالترتيب
+        base = self.url_models.rstrip("/")
+        chat = self.url_chat.rstrip("/")
+        endpoints = list(dict.fromkeys([
+            base,
+            base + "/v1/models",
+            base + "/models",
+            chat + "/v1/models",
+            chat + "/models",
+        ]))
 
         with curl_requests.Session() as session:
-            for endpoint in endpoints:
+            for ep in endpoints:
                 try:
-                    resp = session.get(
-                        endpoint,
-                        headers=self.headers,
-                        impersonate="chrome124",
-                        timeout=10
-                    )
-                    if resp.status_code != 200:
+                    r = session.get(ep, headers=self.headers, impersonate="chrome124", timeout=12)
+                    if r.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
+                    ids = self._parse_models(r.json())
+                    if ids:
+                        logger.info(f"[{self.name}] {len(ids)} models ← {ep}")
+                        return ids
                 except Exception:
                     continue
-
-        return discovered
+        return []
 
     @staticmethod
-    def _parse_models_response(data) -> List[str]:
-        """
-        يستخرج معرّفات النماذج من أي هيكل بيانات محتمل.
-        """
+    def _parse_models(data) -> List[str]:
+        """يستخرج معرّفات النماذج من أي هيكل JSON ممكن."""
         ids: List[str] = []
 
         if isinstance(data, list):
             for item in data:
-                if isinstance(item, str):
-                    ids.append(item)
+                if isinstance(item, str) and item.strip():
+                    ids.append(item.strip())
                 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])
+                    for k in ("id", "name", "model", "model_id", "modelId"):
+                        v = item.get(k)
+                        if isinstance(v, str) and v.strip():
+                            ids.append(v.strip())
                             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"])
+            for key in ("data", "models", "result", "results", "items"):
+                sub = data.get(key)
+                if isinstance(sub, list):
+                    found = BaseProvider._parse_models(sub)
+                    if found:
+                        return found
+            for k in ("id", "name", "model"):
+                v = data.get(k)
+                if isinstance(v, str) and v.strip():
+                    ids.append(v.strip())
 
         return ids
 
-    # ------------------------------------------------------------------
-    # Validation
-    # ------------------------------------------------------------------
-    async def validate_model(self, model: str) -> Tuple[bool, float]:
-        payload = {"model": model, "messages": VALIDATION_PROMPT}
-        start = time.time()
-        result = await self.attempt_request(payload)
-        latency = time.time() - start
-
-        ok = result is not None and "ok" in result.strip().lower()
-        if ok:
-            self.success += 1
-            self.latency = (self.latency + latency) / 2 if self.latency > 0 else latency
-        else:
-            self.fails += 1
-        self.update_health()
-        return ok, latency
-
-    # ------------------------------------------------------------------
-    # Request Handling
-    # ------------------------------------------------------------------
+    # ── إرسال الطلب ──────────────────────────────────────
     async def attempt_request(self, payload: dict) -> Optional[str]:
-        payload = payload.copy()  # prevent mutation leakage
+        payload = payload.copy()
 
         if time.time() < self.cooldown:
             return None
@@ -300,284 +259,201 @@ class BaseProvider:
         try:
             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
-            self.update_health()
-            if self.fails >= 3:
-                self.cooldown = time.time() + 60
-            return None
+                t0   = time.time()
+                text = await loop.run_in_executor(EXECUTOR, self._post_sync, payload)
+                lat  = time.time() - t0
+
+            if text:
+                self._record_success(lat)
+                return text
 
+            self._record_fail()
+            return None
         except Exception:
-            self.fails += 1
-            self.update_health()
+            self._record_fail()
             return None
 
-    def _make_request(self, payload: dict) -> Optional[str]:
+    def _post_sync(self, payload: dict) -> Optional[str]:
         with curl_requests.Session() as session:
             try:
-                resp = session.post(
-                    self.url,
+                r = session.post(
+                    self.url_chat,
                     headers=self.headers,
                     json=payload,
                     impersonate="chrome124",
-                    timeout=25
+                    timeout=30,
                 )
-                if resp.status_code == 200:
-                    data = resp.json()
-                    content = extract_content(data)
-                    if content and str(content).strip():
-                        return str(content).strip()
+                if r.status_code == 200:
+                    content = extract_content(r.json())
+                    if content:
+                        return content
             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")
-
-
-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 []
-
-
+# =========================================================
+# 5. تعريف المزوّدين
+#    أضف أي مزوّد جديد هنا بنفس الطريقة
+# =========================================================
 PROVIDER_INSTANCES: List[BaseProvider] = [
-    GroqProvider(),
-    GeminiProvider(),
-    PollinationsProvider(),
-    OllamaProvider(),
-    PerplexityProvider(),
-    OpenRouterProvider(),
+    BaseProvider("G4F-Groq",        "https://g4f.space/api/groq"),
+    BaseProvider("G4F-Gemini",      "https://g4f.space/api/gemini"),
+    BaseProvider("G4F-Pollinations","https://g4f.space/api/pollinations"),
+    BaseProvider("G4F-Ollama",      "https://g4f.space/api/ollama"),
+    BaseProvider("G4F-Perplexity",  "https://g4f.space/api/perplexity"),
+    BaseProvider("G4F-OpenAI",      "https://g4f.space/api/openai"),
+    BaseProvider("G4F-DeepSeek",    "https://g4f.space/api/deepseek"),
+    BaseProvider("G4F-Mistral",     "https://g4f.space/api/mistral"),
+    BaseProvider("G4F-Claude",      "https://g4f.space/api/claude"),
+    BaseProvider("G4F-Meta",        "https://g4f.space/api/meta"),
 ]
 
 
 # =========================================================
-# 5. إدارة الحالة والتخزين المؤقت
+# 6. التخزين المؤقت
 # =========================================================
 async def load_cache():
     global WORKING_MODELS, PROVIDER_MODEL_MAP
     try:
         if os.path.exists(CACHE_FILE):
             with open(CACHE_FILE, "r", encoding="utf-8") as f:
-                data = json.load(f)
+                d = json.load(f)
             async with STATE_LOCK:
-                WORKING_MODELS = data.get("WORKING_MODELS", {})
-                PROVIDER_MODEL_MAP = data.get("PROVIDER_MODEL_MAP", {})
+                WORKING_MODELS     = d.get("WORKING_MODELS", {})
+                PROVIDER_MODEL_MAP = d.get("PROVIDER_MODEL_MAP", {})
             logger.info(f"✅ Cache loaded — {len(WORKING_MODELS)} models.")
     except Exception as e:
-        logger.error(f"⚠️ Cache load error: {e}")
+        logger.error(f"Cache load error: {e}")
 
 
 async def save_cache():
     try:
         async with STATE_LOCK:
-            snapshot = {
-                "WORKING_MODELS": dict(WORKING_MODELS),
-                "PROVIDER_MODEL_MAP": dict(PROVIDER_MODEL_MAP)
+            snap = {
+                "WORKING_MODELS":    dict(WORKING_MODELS),
+                "PROVIDER_MODEL_MAP": dict(PROVIDER_MODEL_MAP),
             }
         with open(CACHE_FILE, "w", encoding="utf-8") as f:
-            json.dump(snapshot, f, indent=4, ensure_ascii=False)
-        logger.info("💾 Cache saved.")
+            json.dump(snap, f, indent=2, ensure_ascii=False)
     except Exception as e:
-        logger.error(f"⚠️ Cache save error: {e}")
+        logger.error(f"Cache save error: {e}")
 
 
 # =========================================================
-# 6. محرك الاستكشاف والتحقق
+# 7. محرك الاستكشاف — استيراد مباشر بلا تحقق مسبق
 # =========================================================
 async def discovery_engine():
+    """
+    يجلب النماذج مباشرةً من كل مزوّد في نفس الوقت
+    ويضيفها للسجل فوراً — بدون خطوة تحقق تُعيق الاستيراد.
+    الفلترة الوحيدة: استبعاد القائمة السوداء (صور/صوت/تضمين).
+    """
     await load_cache()
 
     while True:
-        logger.info("📡 Starting validated discovery cycle …")
+        logger.info("🔍 Discovery cycle …")
 
-        fresh_provider_map: Dict[str, List[str]] = {}
-        fresh_working_models: Dict[str, dict] = {}
+        fresh_models: Dict[str, dict]      = {}
+        fresh_map:    Dict[str, List[str]] = {}
 
-        # Run provider discovery concurrently
-        tasks = {provider: asyncio.create_task(provider.fetch_models()) for provider in PROVIDER_INSTANCES}
+        # جلب متوازٍ من جميع المزوّدين
+        tasks = {p: asyncio.create_task(p.fetch_models()) for p 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)
+            try:
+                models = await task
+            except Exception as e:
+                logger.warning(f"[{provider.name}] task error: {e}")
+                models = []
 
-                    if model not in fresh_working_models:
-                        fresh_working_models[model] = {
-                            "providers": [],
-                            "latency": latency,
-                            "health": provider.health,
-                            "aliases": provider.aliases
-                        }
+            fresh_map[provider.url_chat] = models
 
-                    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
+            for m in models:
+                if m not in fresh_models:
+                    fresh_models[m] = {
+                        "providers": [],
+                        "latency":   0.0,
+                        "health":    provider.health,
+                    }
+                if provider.url_chat not in fresh_models[m]["providers"]:
+                    fresh_models[m]["providers"].append(provider.url_chat)
 
-            fresh_provider_map[provider.url] = clean_models
-            logger.info(f"✅ [{provider.name}] {len(clean_models)} valid models.")
+            logger.info(f"[{provider.name}] → {len(models)} models imported.")
 
-        # Atomic publish
+        # نشر ذري
         async with STATE_LOCK:
-            global PROVIDER_MODEL_MAP, WORKING_MODELS
-            PROVIDER_MODEL_MAP = fresh_provider_map
-            WORKING_MODELS = fresh_working_models
+            global WORKING_MODELS, PROVIDER_MODEL_MAP
+            WORKING_MODELS     = fresh_models
+            PROVIDER_MODEL_MAP = fresh_map
 
         await save_cache()
-        logger.info(f"🚀 Orchestrator ready — {len(WORKING_MODELS)} active models.")
-        await asyncio.sleep(VALIDATION_INTERVAL)
+        logger.info(f"🚀 Ready — {len(WORKING_MODELS)} total models.")
+        await asyncio.sleep(REFRESH_INTERVAL)
 
 
 # =========================================================
-# 7. المعالج المركزي (Omega Handler)
+# 8. المعالج المركزي
 # =========================================================
 @app.on_event("startup")
-async def startup():
+async def on_startup():
     asyncio.create_task(discovery_engine())
 
 
 @app.api_route("/{path:path}", methods=["GET", "HEAD", "POST", "OPTIONS"])
 async def omega_handler(request: Request, path: str):
-    # ---- 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:
-                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)
+    # 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": "*",
+            },
+        )
+
+    p = path.lower().strip("/")
+
+    # ── قائمة النماذج ─────────────────────────────────────
+    if request.method in ("GET", "HEAD"):
+        if "models" in p or p in ("", "v1", "v1/"):
+            if "models" in p:
+                async with STATE_LOCK:
+                    ids = sorted(WORKING_MODELS.keys())
+                return {
+                    "object": "list",
+                    "data": [
+                        {"id": m, "object": "model", "created": int(time.time()), "owned_by": "omega"}
+                        for m in ids
+                    ],
+                }
+            return Response(status_code=200)
 
-    # ---- Chat completions ----
-    if request.method == "POST" and any(x in path_lower for x in ("messages", "completions", "chat")):
+    # ── إرسال رسائل ───────────────────────────────────────
+    if request.method == "POST" and any(x in p for x in ("messages", "completions", "chat")):
 
-        # --- Auth check (مُصلح) ---
         if not verify_api_key(request):
-            raise HTTPException(status_code=401, detail="Unauthorized: invalid or missing API key.")
+            raise HTTPException(status_code=401, detail="Unauthorized.")
 
-        # --- Parse body ---
         try:
             body = await request.json()
         except Exception:
-            raise HTTPException(status_code=400, detail="Invalid JSON body.")
+            raise HTTPException(status_code=400, detail="Invalid JSON.")
 
-        model    = body.get("model", "gpt-4o")
+        model    = body.get("model", "")
         messages = body.get("messages", [])
 
         if not messages:
-            raise HTTPException(status_code=400, detail="messages field is required.")
+            raise HTTPException(status_code=400, detail="messages is required.")
 
-        # --- Smart routing ---
+        # اختيار المزوّدين القادرين على تقديم هذا النموذج
         async with STATE_LOCK:
-            model_info = WORKING_MODELS.get(model)
-            if model_info and model_info.get("providers"):
-                target_urls = list(model_info["providers"])
-            else:
-                target_urls = [p.url for p in PROVIDER_INSTANCES]
+            info = WORKING_MODELS.get(model)
+            target_urls = list(info["providers"]) if info and info["providers"] else [p.url_chat 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 = [p for p in PROVIDER_INSTANCES if p.url_chat in target_urls]
         providers.sort(key=lambda p: (p.fails, -p.health, p.latency))
 
         reply: Optional[str] = None
@@ -587,64 +463,61 @@ async def omega_handler(request: Request, path: str):
                 continue
             reply = await provider.attempt_request(body)
             if reply:
-                logger.info(f"✅ Served by [{provider.name}] model={model}")
+                logger.info(f"✅ [{provider.name}] served model={model}")
                 break
 
-        # --- Internal fallback via g4f ---
+        # Fallback عبر g4f
         if not reply:
             try:
                 from g4f.client import Client
                 loop = asyncio.get_event_loop()
-
-                def fallback_req():
-                    return (
-                        Client()
+                reply = await loop.run_in_executor(
+                    EXECUTOR,
+                    lambda: Client()
                         .chat.completions.create(model=model, messages=messages)
-                        .choices[0].message.content
-                    )
-
-                reply = await loop.run_in_executor(EXECUTOR, fallback_req)
-                logger.info("🔄 Served via g4f fallback.")
+                        .choices[0].message.content,
+                )
+                logger.info("🔄 g4f fallback used.")
             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.")
+            raise HTTPException(status_code=502, detail="All routes exhausted.")
 
-        # --- Format response ---
-        # Anthropic messages format
-        if "messages" in path_lower and "chat" not in path_lower:
+        # ─ تنسيق الرد ─
+        if "messages" in p and "chat" not in p:
+            # Anthropic format
             return {
-                "id": f"msg_{uuid.uuid4().hex}",
-                "type": "message",
-                "role": "assistant",
-                "model": model,
-                "content": [{"type": "text", "text": reply}],
+                "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}
+                "usage":       {"input_tokens": 0, "output_tokens": 0},
             }
 
-        # OpenAI chat.completions format (default)
+        # OpenAI format
         return {
-            "id": f"chatcmpl-{uuid.uuid4().hex}",
-            "object": "chat.completion",
+            "id":      f"chatcmpl-{uuid.uuid4().hex}",
+            "object":  "chat.completion",
             "created": int(time.time()),
-            "model": model,
+            "model":   model,
             "choices": [
                 {
-                    "index": 0,
-                    "message": {"role": "assistant", "content": reply},
-                    "finish_reason": "stop"
+                    "index":         0,
+                    "message":       {"role": "assistant", "content": reply},
+                    "finish_reason": "stop",
                 }
             ],
-            "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
+            "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0},
         }
 
     return Response(status_code=404)
 
 
 # =========================================================
-# 8. نقطة الدخول
+# 9. نقطة الدخول
 # =========================================================
 if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=PORT, log_level="info")