Update app.py

app.py

@@ -1,6 +1,6 @@
 from fastapi import FastAPI, Request, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import StreamingResponse, JSONResponse
+from fastapi.responses import JSONResponse, StreamingResponse
 from pydantic import BaseModel
 from typing import List, Optional, Dict
 
@@ -8,8 +8,8 @@ import asyncio
 import json
 import time
 import uuid
-import logging
 import random
+import logging
 import httpx
 import g4f
 
@@ -30,170 +30,118 @@ logger = logging.getLogger(__name__)
 
 
 # =====================================================
-# CONFIG
+# APP
 # =====================================================
 
-API_KEY = "sk-your-secret-key"
+app = FastAPI(
+    title="Universal AI Gateway",
+    version="6.0.0"
+)
 
 
 # =====================================================
-# PROXY CONFIG
+# CORS
 # =====================================================
 
-# قائمة البروكسيات - أضف بروكسياتك هنا
-PROXY_LIST = [
-    # "http://user:pass@proxy1:port",
-    # "http://user:pass@proxy2:port",
-    # "socks5://user:pass@proxy3:port",
-]
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# =====================================================
+# CONFIG
+# =====================================================
+
+API_KEY = "sk-your-secret-key"
+
+PROXY_LIST = []
 
-# بروكسي واحد إذا كان لديك
 SINGLE_PROXY = None
-# مثال:
-# "http://user:pass@host:port"
 
 
 # =====================================================
-# PROVIDER MAP - ربط النماذج بمزوديها
+# SAFE PROVIDER GETTER
 # =====================================================
 
-MODEL_PROVIDER_MAP: Dict[str, list] = {
+def provider_exists(name: str):
+    """
+    التحقق من وجود المزود داخل g4f
+    """
 
-    # GPT Models
-    "gpt-4o": [
-        Provider.Blackbox,
-        Provider.Liaobots,
-        Provider.OpenaiChat,
-    ],
-
-    "gpt-4o-mini": [
-        Provider.Blackbox,
-        Provider.DDG,
-        Provider.Liaobots,
-        Provider.OpenaiChat,
-    ],
-
-    "gpt-4": [
-        Provider.Blackbox,
-        Provider.Liaobots,
-        Provider.OpenaiChat,
-    ],
-
-    "gpt-3.5-turbo": [
-        Provider.DDG,
-        Provider.Blackbox,
-        Provider.OpenaiChat,
-    ],
-
-    # Claude Models
-    "claude-3-haiku": [
-        Provider.DDG,
-        Provider.Blackbox,
-    ],
-
-    "claude-3-5-sonnet": [
-        Provider.Blackbox,
-        Provider.Liaobots,
-    ],
-
-    "claude-3-opus": [
-        Provider.Liaobots,
-        Provider.Blackbox,
-    ],
-
-    # Llama Models
-    "llama-3.1-70b": [
-        Provider.Blackbox,
-        Provider.DeepInfra,
-        Provider.Cloudflare,
-    ],
-
-    "llama-3.1-8b": [
-        Provider.Cloudflare,
-        Provider.DeepInfra,
-    ],
-
-    "llama-3.2-90b": [
-        Provider.Blackbox,
-        Provider.DeepInfra,
-    ],
-
-    # Mixtral Models
-    "mixtral-8x7b": [
-        Provider.DeepInfra,
-        Provider.Blackbox,
-    ],
-
-    # Deepseek Models
-    "deepseek-chat": [
-        Provider.DeepInfra,
-        Provider.Blackbox,
-    ],
-
-    "deepseek-v3": [
-        Provider.Blackbox,
-        Provider.DeepInfra,
-    ],
-
-    # Gemini Models
-    "gemini-pro": [
-        Provider.Blackbox,
-        Provider.Liaobots,
-    ],
-
-    "gemini-1.5-pro": [
-        Provider.Blackbox,
-        Provider.Liaobots,
-    ],
-
-    # Qwen Models
-    "qwen-2.5-72b": [
-        Provider.Blackbox,
-        Provider.DeepInfra,
-    ],
-
-    # Default fallback
-    "default": [
-        Provider.Blackbox,
-        Provider.DDG,
-        Provider.DeepInfra,
-    ],
-}
+    return hasattr(Provider, name)
+
+
+def get_provider(name: str):
+    """
+    جلب المزود إذا كان موجود
+    """
+
+    if provider_exists(name):
+        return getattr(Provider, name)
+
+    return None
 
 
 # =====================================================
-# FALLBACK MODELS - إذا فشل النموذج المطلوب
+# AUTO DETECT PROVIDERS
 # =====================================================
 
-FALLBACK_MODELS = [
-    "gpt-4o-mini",
-    "gpt-3.5-turbo",
-    "llama-3.1-70b",
+AVAILABLE_PROVIDERS = []
+
+PREFERRED_PROVIDERS = [
+    "Blackbox",
+    "BlackboxPro",
+    "Liaobots",
+    "DDG",
+    "OpenaiChat",
+    "DeepInfra",
+    "Cloudflare",
+    "RetryProvider",
 ]
 
+for provider_name in PREFERRED_PROVIDERS:
+
+    provider = get_provider(provider_name)
+
+    if provider:
+        AVAILABLE_PROVIDERS.append(provider)
+        logger.info(f"Loaded provider: {provider_name}")
+
+    else:
+        logger.warning(f"Provider not found: {provider_name}")
+
 
 # =====================================================
-# FASTAPI
+# MODEL MAP
 # =====================================================
 
-app = FastAPI(
-    title="Universal AI Gateway",
-    description="بوابة ذكاء اصطناعي شاملة مع دعم البروكسي",
-    version="5.0.0"
-)
+MODEL_PROVIDER_MAP: Dict[str, list] = {
+    "gpt-4o": AVAILABLE_PROVIDERS,
+    "gpt-4o-mini": AVAILABLE_PROVIDERS,
+    "gpt-4": AVAILABLE_PROVIDERS,
+    "gpt-3.5-turbo": AVAILABLE_PROVIDERS,
+    "claude-3-haiku": AVAILABLE_PROVIDERS,
+    "claude-3-sonnet": AVAILABLE_PROVIDERS,
+    "deepseek-chat": AVAILABLE_PROVIDERS,
+    "llama-3.1-70b": AVAILABLE_PROVIDERS,
+    "gemini-pro": AVAILABLE_PROVIDERS,
+    "default": AVAILABLE_PROVIDERS,
+}
 
 
 # =====================================================
-# CORS
+# FALLBACK MODELS
 # =====================================================
 
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+FALLBACK_MODELS = [
+    "gpt-4o-mini",
+    "gpt-3.5-turbo",
+    "deepseek-chat",
+]
 
 
 # =====================================================
@@ -214,75 +162,46 @@ class ChatRequest(BaseModel):
 
 
 # =====================================================
-# PROXY HELPER
+# HELPERS
 # =====================================================
 
-def get_proxy() -> Optional[str]:
-    """الحصول على بروكسي من القائمة"""
+def get_proxy():
 
-    # إذا كان هناك بروكسي واحد محدد
     if SINGLE_PROXY:
-        logger.info(f"Using single proxy: {SINGLE_PROXY[:20]}...")
         return SINGLE_PROXY
 
-    # اختيار عشوائي من القائمة
     if PROXY_LIST:
-        proxy = random.choice(PROXY_LIST)
-        logger.info(f"Using proxy from list: {proxy[:20]}...")
-        return proxy
+        return random.choice(PROXY_LIST)
 
     return None
 
 
-def get_g4f_proxy_config() -> dict:
-    """إعداد البروكسي لـ g4f"""
-
-    proxy = get_proxy()
-
-    if proxy:
-        return {"proxy": proxy}
-
-    return {}
-
-
-# =====================================================
-# CLIENT BUILDER
-# =====================================================
-
-def build_client(proxy: Optional[str] = None) -> Client:
-    """بناء عميل g4f مع البروكسي"""
+def build_client(proxy=None):
 
-    proxy_url = proxy or get_proxy()
+    try:
+        if proxy:
+            return Client(proxies=proxy)
 
-    if proxy_url:
-        try:
-            client = Client(proxies=proxy_url)
-            logger.info("Client created with proxy")
-            return client
+        return Client()
 
-        except Exception as e:
-            logger.warning(f"Failed to create client with proxy: {e}")
+    except Exception as e:
 
-    return Client()
+        logger.error(f"Client error: {e}")
 
+        return Client()
 
-# =====================================================
-# AUTH
-# =====================================================
 
 def verify_api_key(req: Request):
-    """التحقق من مفتاح API"""
 
     auth = req.headers.get("Authorization")
 
-    # السماح بدون مفتاح للاختبار
     if not auth:
         return True
 
     if not auth.startswith("Bearer "):
         raise HTTPException(
             status_code=401,
-            detail="Invalid Authorization Format - يجب أن يبدأ بـ Bearer"
+            detail="Invalid Authorization format"
         )
 
     token = auth.replace("Bearer ", "").strip()
@@ -290,176 +209,112 @@ def verify_api_key(req: Request):
     if token != API_KEY:
         raise HTTPException(
             status_code=403,
-            detail="Invalid API Key - مفتاح API غير صحيح"
+            detail="Invalid API key"
         )
 
     return True
 
 
 # =====================================================
-# CORE: SMART COMPLETION WITH RETRY + FALLBACK
+# SMART COMPLETION
 # =====================================================
 
 async def smart_completion(
     model: str,
     messages: list,
     stream: bool = False,
-    max_retries: int = 3,
-    proxy: Optional[str] = None
+    retries: int = 3
 ):
-    """
-    محاولة ذكية مع:
-    - تجربة عدة مزودين
-    - إعادة المحاولة عند الفشل
-    - التحويل لنموذج بديل
-    """
 
-    # الحصول على قائمة المزودين للنموذج
     providers = MODEL_PROVIDER_MAP.get(
         model,
         MODEL_PROVIDER_MAP["default"]
     )
 
-    # خلط المزودين عشوائياً لتوزيع الحمل
-    providers_shuffled = providers.copy()
-    random.shuffle(providers_shuffled)
+    if not providers:
+        raise HTTPException(
+            status_code=500,
+            detail="No providers available"
+        )
 
-    last_error = None
+    random.shuffle(providers)
 
-    # -----------------------------------------------
-    # المحاولة مع كل مزود
-    # -----------------------------------------------
+    last_error = None
 
-    for attempt in range(max_retries):
+    for attempt in range(retries):
 
-        for provider in providers_shuffled:
+        for provider in providers:
 
             try:
+
                 logger.info(
-                    f"Attempt {attempt + 1} | Model: {model} | Provider: {provider.__name__}"
+                    f"Attempt {attempt+1} | Provider: {provider.__name__}"
                 )
 
+                proxy = get_proxy()
+
                 client = build_client(proxy)
-                proxy_config = get_g4f_proxy_config()
 
                 response = await asyncio.to_thread(
                     client.chat.completions.create,
                     model=model,
                     messages=messages,
                     provider=provider,
-                    stream=stream,
-                    **proxy_config
+                    stream=stream
                 )
 
                 logger.info(
-                    f"✅ Success | Model: {model} | Provider: {provider.__name__}"
+                    f"SUCCESS => {provider.__name__}"
                 )
 
                 return response, model
 
             except Exception as e:
+
                 last_error = e
 
                 logger.warning(
-                    f"❌ Failed | Model: {model} | Provider: {provider.__name__} | Error: {str(e)[:100]}"
+                    f"FAILED => {provider.__name__} | {e}"
                 )
 
-                # انتظار قصير قبل المحاولة التالية
-                await asyncio.sleep(0.5)
-
-        # انتظار قبل دورة المحاولات الجديدة
-        if attempt < max_retries - 1:
-            wait_time = (attempt + 1) * 1.5
-
-            logger.info(
-                f"Waiting {wait_time}s before retry {attempt + 2}..."
-            )
-
-            await asyncio.sleep(wait_time)
+                await asyncio.sleep(1)
 
-    # -----------------------------------------------
-    # Fallback: تجربة نماذج بديلة
-    # -----------------------------------------------
-
-    logger.warning(
-        f"All providers failed for {model}. Trying fallback models..."
-    )
+    # ============================================
+    # FALLBACK MODELS
+    # ============================================
 
     for fallback_model in FALLBACK_MODELS:
 
-        if fallback_model == model:
-            continue
-
-        fallback_providers = MODEL_PROVIDER_MAP.get(
-            fallback_model,
-            MODEL_PROVIDER_MAP["default"]
-        )
-
-        for fb_provider in fallback_providers[:2]:
-
-            try:
-                logger.info(
-                    f"🔄 Fallback | Model: {fallback_model} | Provider: {fb_provider.__name__}"
-                )
-
-                client = build_client(proxy)
-                proxy_config = get_g4f_proxy_config()
-
-                response = await asyncio.to_thread(
-                    client.chat.completions.create,
-                    model=fallback_model,
-                    messages=messages,
-                    provider=fb_provider,
-                    stream=stream,
-                    **proxy_config
-                )
-
-                logger.info(
-                    f"✅ Fallback Success | Model: {fallback_model} | Provider: {fb_provider.__name__}"
-                )
-
-                return response, fallback_model
-
-            except Exception as e:
-
-                logger.warning(
-                    f"❌ Fallback Failed | Model: {fallback_model} | Error: {str(e)[:100]}"
-                )
-
-                await asyncio.sleep(0.3)
-
-    # -----------------------------------------------
-    # آخر محاولة: بدون تحديد مزود
-    # -----------------------------------------------
-
-    try:
+        try:
 
-        logger.info(f"🆘 Last resort attempt for model: {model}")
+            logger.info(
+                f"Trying fallback model: {fallback_model}"
+            )
 
-        client = build_client(proxy)
+            proxy = get_proxy()
 
-        response = await asyncio.to_thread(
-            client.chat.completions.create,
-            model=model,
-            messages=messages,
-            stream=stream
-        )
+            client = build_client(proxy)
 
-        return response, model
+            response = await asyncio.to_thread(
+                client.chat.completions.create,
+                model=fallback_model,
+                messages=messages,
+                stream=stream
+            )
 
-    except Exception as e:
+            return response, fallback_model
 
-        last_error = e
+        except Exception as e:
 
-        logger.error(f"💀 All attempts failed: {str(e)}")
+            logger.warning(
+                f"Fallback failed: {e}"
+            )
 
     raise HTTPException(
         status_code=503,
         detail={
-            "error": "All providers failed",
-            "message": str(last_error),
-            "model_requested": model,
-            "suggestion": "Try again later or use a different model"
+            "error": str(last_error),
+            "message": "All providers failed"
         }
     )
 
@@ -473,135 +328,82 @@ async def root():
 
     return {
         "status": "online",
-        "service": "Universal AI Gateway",
-        "version": "5.0.0",
-        "proxy_enabled": bool(PROXY_LIST or SINGLE_PROXY),
-        "supported_models": list(MODEL_PROVIDER_MAP.keys()),
-        "endpoints": {
-            "chat": "/v1/chat/completions",
-            "models": "/v1/models",
-            "health": "/health"
-        }
+        "version": "6.0.0",
+        "providers_loaded": [
+            p.__name__
+            for p in AVAILABLE_PROVIDERS
+        ]
     }
 
 
 # =====================================================
-# HEALTH CHECK
+# HEALTH
 # =====================================================
 
 @app.get("/health")
-async def health_check():
-    """فحص صحة الخدمة"""
+async def health():
 
     proxy_status = "disabled"
 
-    if SINGLE_PROXY or PROXY_LIST:
+    proxy = get_proxy()
 
-        proxy_status = "enabled"
+    if proxy:
 
-        # اختبار البروكسي
-        proxy = get_proxy()
+        try:
 
-        if proxy:
-            try:
-                async with httpx.AsyncClient(
-                    proxies=proxy,
-                    timeout=10
-                ) as client:
+            async with httpx.AsyncClient(
+                proxies=proxy,
+                timeout=10
+            ) as client:
 
-                    resp = await client.get(
-                        "https://api.ipify.org?format=json"
-                    )
+                r = await client.get(
+                    "https://api.ipify.org?format=json"
+                )
 
-                    ip_data = resp.json()
+                ip = r.json().get("ip")
 
-                    proxy_status = (
-                        f"working - IP: {ip_data.get('ip', 'unknown')}"
-                    )
+                proxy_status = f"working ({ip})"
 
-            except Exception as e:
-                proxy_status = f"error - {str(e)[:50]}"
+        except Exception as e:
+
+            proxy_status = f"error: {e}"
 
     return {
         "status": "healthy",
-        "timestamp": int(time.time()),
         "proxy": proxy_status,
-        "providers_count": len(MODEL_PROVIDER_MAP),
-        "fallback_models": FALLBACK_MODELS
+        "providers_count": len(AVAILABLE_PROVIDERS)
     }
 
 
 # =====================================================
-# MODELS LIST
+# MODELS
 # =====================================================
 
 @app.get("/v1/models")
-async def get_models():
-    """قائمة النماذج المتاحة"""
+async def models():
 
-    models_data = []
+    data = []
 
-    # النماذج من الخريطة
     for model_id in MODEL_PROVIDER_MAP.keys():
 
         if model_id == "default":
             continue
 
-        providers_count = len(MODEL_PROVIDER_MAP[model_id])
-
-        models_data.append({
+        data.append({
             "id": model_id,
             "object": "model",
             "created": int(time.time()),
-            "owned_by": "g4f",
-            "providers_available": providers_count,
-            "permission": [],
-            "root": model_id,
-            "parent": None
+            "owned_by": "g4f"
         })
 
-    # إضافة نماذج إضافية من g4f
-    try:
-
-        if hasattr(g4f.models, "_all_models"):
-
-            all_models = list(g4f.models._all_models)
-
-            existing_ids = {
-                m["id"] for m in models_data
-            }
-
-            for model in all_models[:30]:
-
-                model_str = str(model)
-
-                if model_str not in existing_ids:
-
-                    models_data.append({
-                        "id": model_str,
-                        "object": "model",
-                        "created": int(time.time()),
-                        "owned_by": "g4f",
-                        "providers_available": 1,
-                        "permission": [],
-                        "root": model_str,
-                        "parent": None
-                    })
-
-                    existing_ids.add(model_str)
-
-    except Exception as e:
-        logger.warning(f"Could not fetch g4f models: {e}")
-
     return {
         "object": "list",
-        "data": models_data,
-        "total": len(models_data)
+        "data": data
     }
 
 
 # =====================================================
-# CHAT COMPLETIONS - MAIN ENDPOINT
+# CHAT COMPLETIONS
 # =====================================================
 
 @app.post("/v1/chat/completions")
@@ -609,11 +411,9 @@ async def chat_completions(
     req: Request,
     body: ChatRequest
 ):
-    """نقطة نهاية المحادثة الرئيسية"""
 
     verify_api_key(req)
 
-    # تحويل الرسائل
     messages = [
         {
             "role": m.role,
@@ -623,120 +423,36 @@ async def chat_completions(
     ]
 
     logger.info(
-        f"📨 Request | model={body.model} | stream={body.stream} | messages={len(messages)}"
+        f"Request => model={body.model} stream={body.stream}"
     )
 
     # =================================================
-    # STREAMING
+    # STREAM
     # =================================================
 
     if body.stream:
 
-        async def generate_stream():
+        async def event_stream():
 
             try:
 
-                # الحصول على البروكسي
-                proxy = get_proxy()
-
-                chunk_id = f"chatcmpl-{uuid.uuid4().hex}"
-                actual_model = body.model
-
-                # محاولة مع كل مزود
-                providers = MODEL_PROVIDER_MAP.get(
-                    body.model,
-                    MODEL_PROVIDER_MAP["default"]
+                response, actual_model = await smart_completion(
+                    model=body.model,
+                    messages=messages,
+                    stream=True
                 )
 
-                providers_shuffled = providers.copy()
-                random.shuffle(providers_shuffled)
-
-                response = None
-                last_err = None
-
-                # تجربة كل مزود
-                for provider in providers_shuffled:
-
-                    try:
-                        logger.info(
-                            f"Stream attempt | Provider: {provider.__name__}"
-                        )
-
-                        client = build_client(proxy)
-                        proxy_config = get_g4f_proxy_config()
-
-                        response = await asyncio.to_thread(
-                            client.chat.completions.create,
-                            model=body.model,
-                            messages=messages,
-                            provider=provider,
-                            stream=True,
-                            **proxy_config
-                        )
-
-                        logger.info(
-                            f"✅ Stream connected | Provider: {provider.__name__}"
-                        )
-
-                        break
-
-                    except Exception as e:
-
-                        last_err = e
-
-                        logger.warning(
-                            f"❌ Stream provider failed: {provider.__name__} | {str(e)[:80]}"
-                        )
-
-                        await asyncio.sleep(0.3)
-
-                # إذا فشل كل شيء، جرب بدون مزود محدد
-                if response is None:
-
-                    try:
-                        client = build_client(proxy)
-
-                        response = await asyncio.to_thread(
-                            client.chat.completions.create,
-                            model=body.model,
-                            messages=messages,
-                            stream=True
-                        )
-
-                        logger.info(
-                            "✅ Stream connected without specific provider"
-                        )
-
-                    except Exception as e:
-
-                        last_err = e
-
-                        logger.error(
-                            f"💀 Stream completely failed: {e}"
-                        )
-
-                        error_payload = {
-                            "error": {
-                                "message": str(e),
-                                "type": "server_error",
-                                "code": 503
-                            }
-                        }
-
-                        yield f"data: {json.dumps(error_payload)}\n\n"
-                        return
-
-                # إرسال البيانات
-                has_content = False
+                chunk_id = f"chatcmpl-{uuid.uuid4().hex}"
 
                 for chunk in response:
 
                     try:
+
                         content = ""
 
                         if (
-                            chunk.choices
-                            and len(chunk.choices) > 0
+                            hasattr(chunk, "choices")
+                            and chunk.choices
                             and chunk.choices[0].delta
                             and chunk.choices[0].delta.content
                         ):
@@ -744,8 +460,6 @@ async def chat_completions(
 
                         if content:
 
-                            has_content = True
-
                             payload = {
                                 "id": chunk_id,
                                 "object": "chat.completion.chunk",
@@ -768,63 +482,28 @@ async def chat_completions(
                                 f"{json.dumps(payload, ensure_ascii=False)}\n\n"
                             )
 
-                            await asyncio.sleep(0)
+                    except Exception as e:
 
-                    except Exception as chunk_error:
                         logger.error(
-                            f"Chunk processing error: {chunk_error}"
+                            f"Chunk error: {e}"
                         )
 
-                        continue
-
-                # إذا لم يكن هناك محتوى
-                if not has_content:
-                    logger.warning("Stream produced no content!")
-
-                # إشارة الانتهاء
-                final_payload = {
-                    "id": chunk_id,
-                    "object": "chat.completion.chunk",
-                    "created": int(time.time()),
-                    "model": actual_model,
-                    "choices": [
-                        {
-                            "index": 0,
-                            "delta": {},
-                            "finish_reason": "stop"
-                        }
-                    ]
-                }
-
-                yield (
-                    f"data: "
-                    f"{json.dumps(final_payload)}\n\n"
-                )
-
                 yield "data: [DONE]\n\n"
 
             except Exception as e:
 
-                logger.error(f"Stream generation error: {e}")
-
                 error_payload = {
-                    "error": {
-                        "message": str(e),
-                        "type": "server_error"
-                    }
+                    "error": str(e)
                 }
 
-                yield f"data: {json.dumps(error_payload)}\n\n"
+                yield (
+                    f"data: "
+                    f"{json.dumps(error_payload)}\n\n"
+                )
 
         return StreamingResponse(
-            generate_stream(),
-            media_type="text/event-stream",
-            headers={
-                "Cache-Control": "no-cache",
-                "Connection": "keep-alive",
-                "X-Accel-Buffering": "no",
-                "Transfer-Encoding": "chunked"
-            }
+            event_stream(),
+            media_type="text/event-stream"
         )
 
     # =================================================
@@ -833,33 +512,24 @@ async def chat_completions(
 
     try:
 
-        proxy = get_proxy()
-
         response, actual_model = await smart_completion(
             model=body.model,
             messages=messages,
-            stream=False,
-            max_retries=3,
-            proxy=proxy
+            stream=False
         )
 
-        # استخراج المحتوى
         assistant_message = ""
 
         try:
+
             assistant_message = (
-                response.choices[0].message.content or ""
+                response.choices[0].message.content
             )
 
-        except AttributeError:
-
-            try:
-                assistant_message = str(response)
+        except Exception:
 
-            except Exception:
-                assistant_message = "Error extracting response"
+            assistant_message = str(response)
 
-        # حساب الرموز تقريبياً
         prompt_tokens = sum(
             len(m["content"].split())
             for m in messages
@@ -898,15 +568,11 @@ async def chat_completions(
 
     except Exception as e:
 
-        logger.error(f"Chat completion error: {e}")
+        logger.error(f"Chat error: {e}")
 
         raise HTTPException(
             status_code=500,
-            detail={
-                "error": str(e),
-                "model": body.model,
-                "message": "Internal server error"
-            }
+            detail=str(e)
         )
 
 
@@ -918,16 +584,10 @@ if __name__ == "__main__":
 
     import uvicorn
 
-    logger.info(
-        "🚀 Starting Universal AI Gateway v5.0.0"
-    )
-
-    logger.info(
-        f"🔌 Proxy enabled: {bool(PROXY_LIST or SINGLE_PROXY)}"
-    )
+    logger.info("Starting Universal AI Gateway v6")
 
     logger.info(
-        f"📦 Models configured: {len(MODEL_PROVIDER_MAP)}"
+        f"Providers loaded: {len(AVAILABLE_PROVIDERS)}"
     )
 
     uvicorn.run(