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 JSONResponse, StreamingResponse
+from fastapi.responses import StreamingResponse, JSONResponse
 from pydantic import BaseModel
 from typing import List, Optional, Dict
 
@@ -8,8 +8,8 @@ import asyncio
 import json
 import time
 import uuid
-import random
 import logging
+import random
 import httpx
 import g4f
 
@@ -30,120 +30,236 @@ logger = logging.getLogger(__name__)
 
 
 # =====================================================
-# APP
-# =====================================================
-
-app = FastAPI(
-    title="Universal AI Gateway",
-    version="6.0.0"
-)
-
-
-# =====================================================
-# CORS
+# CONFIG
 # =====================================================
 
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+API_KEY = "sk-your-secret-key"
 
 
 # =====================================================
-# CONFIG
+# PROXY CONFIG
 # =====================================================
 
-API_KEY = "sk-your-secret-key"
-
-PROXY_LIST = []
+# قائمة البروكسيات - أضف بروكسياتك هنا
+PROXY_LIST = [
+    # "http://user:pass@proxy1:port",
+    # "http://user:pass@proxy2:port",
+    # "socks5://user:pass@proxy3:port",
+]
 
+# بروكسي واحد إذا كان لديك
 SINGLE_PROXY = None
 
+# مثال:
+# "http://user:pass@host:port"
+
 
 # =====================================================
-# SAFE PROVIDER GETTER
+# PROVIDER SAFE LOADER
 # =====================================================
 
-def provider_exists(name: str):
+def safe_provider(name: str):
     """
-    التحقق من وجود المزود داخل g4f
+    تحميل المزود إذا كان موجود داخل g4f
     """
 
-    return hasattr(Provider, name)
-
-
-def get_provider(name: str):
-    """
-    جلب المزود إذا كان موجود
-    """
-
-    if provider_exists(name):
+    if hasattr(Provider, name):
         return getattr(Provider, name)
 
+    logger.warning(f"Provider not found: {name}")
+
     return None
 
 
 # =====================================================
-# AUTO DETECT PROVIDERS
+# PROVIDERS
 # =====================================================
 
-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}")
+BLACKBOX = safe_provider("Blackbox")
+LIAOBOTS = safe_provider("Liaobots")
+OPENAICHAT = safe_provider("OpenaiChat")
+DDG = safe_provider("DDG")
+DEEPINFRA = safe_provider("DeepInfra")
+CLOUDFLARE = safe_provider("Cloudflare")
 
 
 # =====================================================
-# MODEL MAP
+# PROVIDER MAP - ربط النماذج بمزوديها
 # =====================================================
 
 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,
+
+    # GPT Models
+    "gpt-4o": [
+        p for p in [
+            BLACKBOX,
+            LIAOBOTS,
+            OPENAICHAT
+        ] if p
+    ],
+
+    "gpt-4o-mini": [
+        p for p in [
+            BLACKBOX,
+            DDG,
+            LIAOBOTS,
+            OPENAICHAT
+        ] if p
+    ],
+
+    "gpt-4": [
+        p for p in [
+            BLACKBOX,
+            LIAOBOTS,
+            OPENAICHAT
+        ] if p
+    ],
+
+    "gpt-3.5-turbo": [
+        p for p in [
+            DDG,
+            BLACKBOX,
+            OPENAICHAT
+        ] if p
+    ],
+
+    # Claude Models
+    "claude-3-haiku": [
+        p for p in [
+            DDG,
+            BLACKBOX
+        ] if p
+    ],
+
+    "claude-3-5-sonnet": [
+        p for p in [
+            BLACKBOX,
+            LIAOBOTS
+        ] if p
+    ],
+
+    "claude-3-opus": [
+        p for p in [
+            LIAOBOTS,
+            BLACKBOX
+        ] if p
+    ],
+
+    # Llama Models
+    "llama-3.1-70b": [
+        p for p in [
+            BLACKBOX,
+            DEEPINFRA,
+            CLOUDFLARE
+        ] if p
+    ],
+
+    "llama-3.1-8b": [
+        p for p in [
+            CLOUDFLARE,
+            DEEPINFRA
+        ] if p
+    ],
+
+    "llama-3.2-90b": [
+        p for p in [
+            BLACKBOX,
+            DEEPINFRA
+        ] if p
+    ],
+
+    # Mixtral Models
+    "mixtral-8x7b": [
+        p for p in [
+            DEEPINFRA,
+            BLACKBOX
+        ] if p
+    ],
+
+    # Deepseek Models
+    "deepseek-chat": [
+        p for p in [
+            DEEPINFRA,
+            BLACKBOX
+        ] if p
+    ],
+
+    "deepseek-v3": [
+        p for p in [
+            BLACKBOX,
+            DEEPINFRA
+        ] if p
+    ],
+
+    # Gemini Models
+    "gemini-pro": [
+        p for p in [
+            BLACKBOX,
+            LIAOBOTS
+        ] if p
+    ],
+
+    "gemini-1.5-pro": [
+        p for p in [
+            BLACKBOX,
+            LIAOBOTS
+        ] if p
+    ],
+
+    # Qwen Models
+    "qwen-2.5-72b": [
+        p for p in [
+            BLACKBOX,
+            DEEPINFRA
+        ] if p
+    ],
+
+    # Default fallback
+    "default": [
+        p for p in [
+            BLACKBOX,
+            DDG,
+            DEEPINFRA
+        ] if p
+    ],
 }
 
 
 # =====================================================
-# FALLBACK MODELS
+# FALLBACK MODELS - إذا فشل النموذج المطلوب
 # =====================================================
 
 FALLBACK_MODELS = [
     "gpt-4o-mini",
     "gpt-3.5-turbo",
-    "deepseek-chat",
+    "llama-3.1-70b",
 ]
 
 
+# =====================================================
+# FASTAPI
+# =====================================================
+
+app = FastAPI(
+    title="Universal AI Gateway",
+    description="بوابة ذكاء اصطناعي شاملة مع دعم البروكسي",
+    version="5.0.0"
+)
+
+
+# =====================================================
+# CORS
+# =====================================================
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
 # =====================================================
 # MODELS
 # =====================================================
@@ -162,36 +278,62 @@ class ChatRequest(BaseModel):
 
 
 # =====================================================
-# HELPERS
+# PROXY HELPER
 # =====================================================
 
-def get_proxy():
+def get_proxy() -> Optional[str]:
+    """الحصول على بروكسي من القائمة"""
 
     if SINGLE_PROXY:
+        logger.info(f"Using single proxy: {SINGLE_PROXY[:20]}...")
         return SINGLE_PROXY
 
     if PROXY_LIST:
-        return random.choice(PROXY_LIST)
+        proxy = random.choice(PROXY_LIST)
+        logger.info(f"Using proxy from list: {proxy[:20]}...")
+        return proxy
 
     return None
 
 
-def build_client(proxy=None):
+def get_g4f_proxy_config() -> dict:
+    """إعداد البروكسي لـ g4f"""
 
-    try:
-        if proxy:
-            return Client(proxies=proxy)
+    proxy = get_proxy()
 
-        return Client()
+    if proxy:
+        return {"proxy": proxy}
 
-    except Exception as e:
+    return {}
 
-        logger.error(f"Client error: {e}")
 
-        return Client()
+# =====================================================
+# CLIENT BUILDER
+# =====================================================
 
+def build_client(proxy: Optional[str] = None) -> Client:
+    """بناء عميل g4f مع البروكسي"""
+
+    proxy_url = proxy or get_proxy()
+
+    if proxy_url:
+        try:
+            client = Client(proxies=proxy_url)
+            logger.info("Client created with proxy")
+            return client
+
+        except Exception as e:
+            logger.warning(f"Failed to create client with proxy: {e}")
+
+    return Client()
+
+
+# =====================================================
+# AUTH
+# =====================================================
 
 def verify_api_key(req: Request):
+    """التحقق من مفتاح API"""
 
     auth = req.headers.get("Authorization")
 
@@ -201,7 +343,7 @@ def verify_api_key(req: Request):
     if not auth.startswith("Bearer "):
         raise HTTPException(
             status_code=401,
-            detail="Invalid Authorization format"
+            detail="Invalid Authorization Format - يجب أن يبدأ بـ Bearer"
         )
 
     token = auth.replace("Bearer ", "").strip()
@@ -209,21 +351,22 @@ def verify_api_key(req: Request):
     if token != API_KEY:
         raise HTTPException(
             status_code=403,
-            detail="Invalid API key"
+            detail="Invalid API Key - مفتاح API غير صحيح"
         )
 
     return True
 
 
 # =====================================================
-# SMART COMPLETION
+# CORE: SMART COMPLETION WITH RETRY + FALLBACK
 # =====================================================
 
 async def smart_completion(
     model: str,
     messages: list,
     stream: bool = False,
-    retries: int = 3
+    max_retries: int = 3,
+    proxy: Optional[str] = None
 ):
 
     providers = MODEL_PROVIDER_MAP.get(
@@ -231,40 +374,35 @@ async def smart_completion(
         MODEL_PROVIDER_MAP["default"]
     )
 
-    if not providers:
-        raise HTTPException(
-            status_code=500,
-            detail="No providers available"
-        )
-
-    random.shuffle(providers)
+    providers_shuffled = providers.copy()
+    random.shuffle(providers_shuffled)
 
     last_error = None
 
-    for attempt in range(retries):
+    for attempt in range(max_retries):
 
-        for provider in providers:
+        for provider in providers_shuffled:
 
             try:
-
                 logger.info(
-                    f"Attempt {attempt+1} | Provider: {provider.__name__}"
+                    f"Attempt {attempt+1} | Model: {model} | 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
+                    stream=stream,
+                    **proxy_config
                 )
 
                 logger.info(
-                    f"SUCCESS => {provider.__name__}"
+                    f"SUCCESS | Model: {model} | Provider: {provider.__name__}"
                 )
 
                 return response, model
@@ -274,47 +412,107 @@ async def smart_completion(
                 last_error = e
 
                 logger.warning(
-                    f"FAILED => {provider.__name__} | {e}"
+                    f"FAILED | Model: {model} | Provider: {provider.__name__} | Error: {str(e)[:100]}"
                 )
 
-                await asyncio.sleep(1)
+                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..."
+            )
+
+            await asyncio.sleep(wait_time)
+
+    # =================================================
     # FALLBACK MODELS
-    # ============================================
+    # =================================================
+
+    logger.warning(
+        f"All providers failed for {model}"
+    )
 
     for fallback_model in FALLBACK_MODELS:
 
-        try:
+        if fallback_model == model:
+            continue
 
-            logger.info(
-                f"Trying fallback model: {fallback_model}"
-            )
+        fallback_providers = MODEL_PROVIDER_MAP.get(
+            fallback_model,
+            MODEL_PROVIDER_MAP["default"]
+        )
 
-            proxy = get_proxy()
+        for fb_provider in fallback_providers[:2]:
 
-            client = build_client(proxy)
+            try:
+                logger.info(
+                    f"Fallback => {fallback_model} | Provider => {fb_provider.__name__}"
+                )
 
-            response = await asyncio.to_thread(
-                client.chat.completions.create,
-                model=fallback_model,
-                messages=messages,
-                stream=stream
-            )
+                client = build_client(proxy)
 
-            return response, fallback_model
+                proxy_config = get_g4f_proxy_config()
 
-        except Exception as e:
+                response = await asyncio.to_thread(
+                    client.chat.completions.create,
+                    model=fallback_model,
+                    messages=messages,
+                    provider=fb_provider,
+                    stream=stream,
+                    **proxy_config
+                )
 
-            logger.warning(
-                f"Fallback failed: {e}"
-            )
+                logger.info(
+                    f"Fallback Success => {fallback_model}"
+                )
+
+                return response, fallback_model
+
+            except Exception as e:
+
+                logger.warning(
+                    f"Fallback Failed => {fallback_model} | {str(e)[:100]}"
+                )
+
+                await asyncio.sleep(0.3)
+
+    # =================================================
+    # LAST ATTEMPT
+    # =================================================
+
+    try:
+
+        logger.info(
+            f"Last attempt without provider => {model}"
+        )
+
+        client = build_client(proxy)
+
+        response = await asyncio.to_thread(
+            client.chat.completions.create,
+            model=model,
+            messages=messages,
+            stream=stream
+        )
+
+        return response, model
+
+    except Exception as e:
+
+        last_error = e
+
+        logger.error(f"All attempts failed => {e}")
 
     raise HTTPException(
         status_code=503,
         detail={
-            "error": str(last_error),
-            "message": "All providers failed"
+            "error": "All providers failed",
+            "message": str(last_error),
+            "model_requested": model,
+            "suggestion": "Try another model"
         }
     )
 
@@ -328,77 +526,127 @@ async def root():
 
     return {
         "status": "online",
-        "version": "6.0.0",
-        "providers_loaded": [
-            p.__name__
-            for p in AVAILABLE_PROVIDERS
-        ]
+        "service": "Universal AI Gateway",
+        "version": "5.0.0",
+        "proxy_enabled": bool(PROXY_LIST or SINGLE_PROXY),
+        "supported_models": list(MODEL_PROVIDER_MAP.keys())
     }
 
 
 # =====================================================
-# HEALTH
+# HEALTH CHECK
 # =====================================================
 
 @app.get("/health")
-async def health():
+async def health_check():
 
     proxy_status = "disabled"
 
-    proxy = get_proxy()
+    if SINGLE_PROXY or PROXY_LIST:
 
-    if proxy:
+        proxy_status = "enabled"
 
-        try:
+        proxy = get_proxy()
 
-            async with httpx.AsyncClient(
-                proxies=proxy,
-                timeout=10
-            ) as client:
+        if proxy:
 
-                r = await client.get(
-                    "https://api.ipify.org?format=json"
-                )
+            try:
 
-                ip = r.json().get("ip")
+                async with httpx.AsyncClient(
+                    proxies=proxy,
+                    timeout=10
+                ) as client:
 
-                proxy_status = f"working ({ip})"
+                    resp = await client.get(
+                        "https://api.ipify.org?format=json"
+                    )
 
-        except Exception as e:
+                    ip_data = resp.json()
 
-            proxy_status = f"error: {e}"
+                    proxy_status = (
+                        f"working - IP: {ip_data.get('ip', 'unknown')}"
+                    )
+
+            except Exception as e:
+
+                proxy_status = f"error - {str(e)[:50]}"
 
     return {
         "status": "healthy",
+        "timestamp": int(time.time()),
         "proxy": proxy_status,
-        "providers_count": len(AVAILABLE_PROVIDERS)
+        "providers_count": len(MODEL_PROVIDER_MAP),
+        "fallback_models": FALLBACK_MODELS
     }
 
 
 # =====================================================
-# MODELS
+# MODELS LIST
 # =====================================================
 
 @app.get("/v1/models")
-async def models():
+async def get_models():
 
-    data = []
+    models_data = []
 
     for model_id in MODEL_PROVIDER_MAP.keys():
 
         if model_id == "default":
             continue
 
-        data.append({
+        providers_count = len(MODEL_PROVIDER_MAP[model_id])
+
+        models_data.append({
             "id": model_id,
             "object": "model",
             "created": int(time.time()),
-            "owned_by": "g4f"
+            "owned_by": "g4f",
+            "providers_available": providers_count,
+            "permission": [],
+            "root": model_id,
+            "parent": None
         })
 
+    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": data
+        "data": models_data,
+        "total": len(models_data)
     }
 
 
@@ -423,16 +671,16 @@ async def chat_completions(
     ]
 
     logger.info(
-        f"Request => model={body.model} stream={body.stream}"
+        f"Request | model={body.model} | stream={body.stream}"
     )
 
     # =================================================
-    # STREAM
+    # STREAMING
     # =================================================
 
     if body.stream:
 
-        async def event_stream():
+        async def generate_stream():
 
             try:
 
@@ -451,8 +699,8 @@ async def chat_completions(
                         content = ""
 
                         if (
-                            hasattr(chunk, "choices")
-                            and chunk.choices
+                            chunk.choices
+                            and len(chunk.choices) > 0
                             and chunk.choices[0].delta
                             and chunk.choices[0].delta.content
                         ):
@@ -482,18 +730,46 @@ async def chat_completions(
                                 f"{json.dumps(payload, ensure_ascii=False)}\n\n"
                             )
 
-                    except Exception as e:
+                            await asyncio.sleep(0)
+
+                    except Exception as chunk_error:
 
                         logger.error(
-                            f"Chunk error: {e}"
+                            f"Chunk processing error: {chunk_error}"
                         )
 
+                        continue
+
+                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": str(e)
+                    "error": {
+                        "message": str(e),
+                        "type": "server_error"
+                    }
                 }
 
                 yield (
@@ -502,8 +778,14 @@ async def chat_completions(
                 )
 
         return StreamingResponse(
-            event_stream(),
-            media_type="text/event-stream"
+            generate_stream(),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "X-Accel-Buffering": "no",
+                "Transfer-Encoding": "chunked"
+            }
         )
 
     # =================================================
@@ -512,10 +794,14 @@ async def chat_completions(
 
     try:
 
+        proxy = get_proxy()
+
         response, actual_model = await smart_completion(
             model=body.model,
             messages=messages,
-            stream=False
+            stream=False,
+            max_retries=3,
+            proxy=proxy
         )
 
         assistant_message = ""
@@ -523,12 +809,16 @@ async def chat_completions(
         try:
 
             assistant_message = (
-                response.choices[0].message.content
+                response.choices[0].message.content or ""
             )
 
-        except Exception:
+        except AttributeError:
 
-            assistant_message = str(response)
+            try:
+                assistant_message = str(response)
+
+            except Exception:
+                assistant_message = "Error extracting response"
 
         prompt_tokens = sum(
             len(m["content"].split())
@@ -568,11 +858,15 @@ async def chat_completions(
 
     except Exception as e:
 
-        logger.error(f"Chat error: {e}")
+        logger.error(f"Chat completion error: {e}")
 
         raise HTTPException(
             status_code=500,
-            detail=str(e)
+            detail={
+                "error": str(e),
+                "model": body.model,
+                "message": "Internal server error"
+            }
         )
 
 
@@ -584,10 +878,16 @@ if __name__ == "__main__":
 
     import uvicorn
 
-    logger.info("Starting Universal AI Gateway v6")
+    logger.info(
+        "Starting Universal AI Gateway v5.0.0"
+    )
+
+    logger.info(
+        f"Proxy enabled: {bool(PROXY_LIST or SINGLE_PROXY)}"
+    )
 
     logger.info(
-        f"Providers loaded: {len(AVAILABLE_PROVIDERS)}"
+        f"Models configured: {len(MODEL_PROVIDER_MAP)}"
     )
 
     uvicorn.run(