Update app.py

app.py

@@ -1,22 +1,28 @@
-from fastapi import FastAPI, Request, HTTPException
+
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import StreamingResponse, JSONResponse
 from pydantic import BaseModel
-from typing import List, Optional
+from typing import List, Optional, Dict
 import asyncio
 import json
 import time
 import uuid
 import logging
+import random
+import httpx
 
 import g4f
 from g4f.client import Client
+from g4f import Provider
 
 # =====================================================
 # LOGGING
 # =====================================================
 
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s"
+)
 logger = logging.getLogger(__name__)
 
 # =====================================================
@@ -25,13 +31,128 @@ logger = logging.getLogger(__name__)
 
 API_KEY = "sk-your-secret-key"
 
+# =====================================================
+# PROXY CONFIG
+# =====================================================
+
+# قائمة البروكسيات - أضف بروكسياتك هنا
+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"
+
+# =====================================================
+# PROVIDER MAP - ربط النماذج بمزوديها
+# =====================================================
+
+MODEL_PROVIDER_MAP: Dict[str, list] = {
+    # 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,
+    ],
+}
+
+# =====================================================
+# FALLBACK MODELS - إذا فشل النموذج المطلوب
+# =====================================================
+
+FALLBACK_MODELS = [
+    "gpt-4o-mini",
+    "gpt-3.5-turbo",
+    "llama-3.1-70b",
+]
+
 # =====================================================
 # FASTAPI
 # =====================================================
 
 app = FastAPI(
     title="Universal AI Gateway",
-    version="4.0.0"
+    description="بوابة ذكاء اصطناعي شاملة مع دعم البروكسي",
+    version="5.0.0"
 )
 
 # =====================================================
@@ -61,22 +182,67 @@ class ChatRequest(BaseModel):
     temperature: Optional[float] = 0.7
     max_tokens: Optional[int] = 4096
 
+# =====================================================
+# PROXY HELPER
+# =====================================================
+
+def get_proxy() -> Optional[str]:
+    """الحصول على بروكسي من القائمة"""
+
+    # إذا كان هناك بروكسي واحد محدد
+    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 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 مع البروكسي"""
+    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")
 
-    # السماح للاختبار
+    # السماح بدون مفتاح للاختبار
     if not auth:
         return True
 
     if not auth.startswith("Bearer "):
         raise HTTPException(
             status_code=401,
-            detail="Invalid Authorization Format"
+            detail="Invalid Authorization Format - يجب أن يبدأ بـ Bearer"
         )
 
     token = auth.replace("Bearer ", "").strip()
@@ -84,83 +250,289 @@ 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
 
+# =====================================================
+# CORE: SMART COMPLETION WITH RETRY + FALLBACK
+# =====================================================
+
+async def smart_completion(
+    model: str,
+    messages: list,
+    stream: bool = False,
+    max_retries: int = 3,
+    proxy: Optional[str] = None
+):
+    """
+    محاولة ذكية مع:
+    - تجربة عدة مزودين
+    - إعادة المحاولة عند الفشل
+    - التحويل لنموذج بديل
+    """
+
+    # الحصول على قائمة المزودين للنموذج
+    providers = MODEL_PROVIDER_MAP.get(
+        model,
+        MODEL_PROVIDER_MAP["default"]
+    )
+
+    # خلط المزودين عشوائياً لتوزيع الحمل
+    providers_shuffled = providers.copy()
+    random.shuffle(providers_shuffled)
+
+    last_error = None
+
+    # -----------------------------------------------
+    # المحاولة مع كل مزود
+    # -----------------------------------------------
+
+    for attempt in range(max_retries):
+
+        for provider in providers_shuffled:
+
+            try:
+
+                logger.info(
+                    f"Attempt {attempt+1} | Model: {model} | Provider: {provider.__name__}"
+                )
+
+                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
+                )
+
+                logger.info(
+                    f"✅ Success | Model: {model} | Provider: {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]}"
+                )
+
+                # انتظار قصير قبل المحاولة التالية
+                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)
+
+    # -----------------------------------------------
+    # Fallback: تجربة نماذج بديلة
+    # -----------------------------------------------
+
+    logger.warning(
+        f"All providers failed for {model}. Trying 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:
+
+        logger.info(f"🆘 Last resort attempt for model: {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: {str(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"
+        }
+    )
+
 # =====================================================
 # ROOT
 # =====================================================
 
 @app.get("/")
 async def root():
-
     return {
         "status": "online",
         "service": "Universal AI Gateway",
-        "version": "4.0.0"
+        "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"
+        }
     }
 
 # =====================================================
-# MODELS
+# HEALTH CHECK
 # =====================================================
 
-@app.get("/v1/models")
-async def get_models():
+@app.get("/health")
+async def health_check():
+    """فحص صحة الخدمة"""
 
-    models_data = []
+    proxy_status = "disabled"
 
-    fallback_models = [
-        "gpt-4o-mini",
-        "gpt-4o",
-        "gpt-4",
-        "gpt-3.5-turbo",
-        "claude-3-haiku",
-        "llama-3.1-70b",
-        "mixtral-8x7b",
-        "deepseek-chat",
-        "gemini-pro"
-    ]
+    if SINGLE_PROXY or PROXY_LIST:
+        proxy_status = "enabled"
 
-    try:
+        # اختبار البروكسي
+        proxy = get_proxy()
+        if proxy:
+            try:
+                async with httpx.AsyncClient(
+                    proxies=proxy,
+                    timeout=10
+                ) as client:
+                    resp = await client.get("https://api.ipify.org?format=json")
+                    ip_data = resp.json()
+                    proxy_status = f"working - IP: {ip_data.get('ip', 'unknown')}"
+            except Exception as e:
+                proxy_status = f"error - {str(e)[:50]}"
 
-        if hasattr(g4f.models, "_all_models"):
+    return {
+        "status": "healthy",
+        "timestamp": int(time.time()),
+        "proxy": proxy_status,
+        "providers_count": len(MODEL_PROVIDER_MAP),
+        "fallback_models": FALLBACK_MODELS
+    }
 
-            all_models = list(g4f.models._all_models)
+# =====================================================
+# MODELS LIST
+# =====================================================
 
-            for model in all_models[:50]:
+@app.get("/v1/models")
+async def get_models():
+    """قائمة النماذج المتاحة"""
 
-                models_data.append({
-                    "id": str(model),
-                    "object": "model",
-                    "created": int(time.time()),
-                    "owned_by": "g4f"
-                })
+    models_data = []
 
-    except Exception as e:
+    # النماذج من الخريطة
+    for model_id in MODEL_PROVIDER_MAP.keys():
+        if model_id == "default":
+            continue
 
-        logger.error(f"Models error: {e}")
+        providers_count = len(MODEL_PROVIDER_MAP[model_id])
 
-    # fallback
-    if not models_data:
+        models_data.append({
+            "id": model_id,
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "g4f",
+            "providers_available": providers_count,
+            "permission": [],
+            "root": model_id,
+            "parent": None
+        })
 
-        for model in fallback_models:
+    # إضافة نماذج إضافية من 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)
 
-            models_data.append({
-                "id": model,
-                "object": "model",
-                "created": int(time.time()),
-                "owned_by": "g4f"
-            })
+    except Exception as e:
+        logger.warning(f"Could not fetch g4f models: {e}")
 
     return {
         "object": "list",
-        "data": models_data
+        "data": models_data,
+        "total": len(models_data)
     }
 
 # =====================================================
-# CHAT COMPLETIONS
+# CHAT COMPLETIONS - MAIN ENDPOINT
 # =====================================================
 
 @app.post("/v1/chat/completions")
@@ -168,19 +540,18 @@ async def chat_completions(
     req: Request,
     body: ChatRequest
 ):
+    """نقطة نهاية المحادثة الرئيسية"""
 
     verify_api_key(req)
 
+    # تحويل الرسائل
     messages = [
-        {
-            "role": m.role,
-            "content": m.content
-        }
+        {"role": m.role, "content": m.content}
         for m in body.messages
     ]
 
     logger.info(
-        f"Request model={body.model} stream={body.stream}"
+        f"📨 Request | model={body.model} | stream={body.stream} | messages={len(messages)}"
     )
 
     # =================================================
@@ -193,15 +564,85 @@ async def chat_completions(
 
             try:
 
-                client = Client()
+                # الحصول على البروكسي
+                proxy = get_proxy()
+                chunk_id = f"chatcmpl-{uuid.uuid4().hex}"
+                actual_model = body.model
 
-                response = client.chat.completions.create(
-                    model=body.model,
-                    messages=messages,
-                    stream=True
+                # محاولة مع كل مزود
+                providers = MODEL_PROVIDER_MAP.get(
+                    body.model,
+                    MODEL_PROVIDER_MAP["default"]
                 )
 
-                chunk_id = f"chatcmpl-{uuid.uuid4().hex}"
+                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
 
                 for chunk in response:
 
@@ -211,6 +652,7 @@ async def chat_completions(
 
                         if (
                             chunk.choices
+                            and len(chunk.choices) > 0
                             and chunk.choices[0].delta
                             and chunk.choices[0].delta.content
                         ):
@@ -218,15 +660,18 @@ async def chat_completions(
 
                         if content:
 
+                            has_content = True
+
                             payload = {
                                 "id": chunk_id,
                                 "object": "chat.completion.chunk",
                                 "created": int(time.time()),
-                                "model": body.model,
+                                "model": actual_model,
                                 "choices": [
                                     {
                                         "index": 0,
                                         "delta": {
+                                            "role": "assistant",
                                             "content": content
                                         },
                                         "finish_reason": None
@@ -234,21 +679,23 @@ async def chat_completions(
                                 ]
                             }
 
-                            yield f"data: {json.dumps(payload)}\n\n"
-
+                            yield f"data: {json.dumps(payload, ensure_ascii=False)}\n\n"
                             await asyncio.sleep(0)
 
                     except Exception as chunk_error:
+                        logger.error(f"Chunk processing error: {chunk_error}")
+                        continue
 
-                        logger.error(
-                            f"Chunk error: {chunk_error}"
-                        )
+                # إذا لم يكن هناك محتوى
+                if not has_content:
+                    logger.warning("Stream produced no content!")
 
+                # إشارة الانتهاء
                 final_payload = {
                     "id": chunk_id,
                     "object": "chat.completion.chunk",
                     "created": int(time.time()),
-                    "model": body.model,
+                    "model": actual_model,
                     "choices": [
                         {
                             "index": 0,
@@ -259,12 +706,11 @@ async def chat_completions(
                 }
 
                 yield f"data: {json.dumps(final_payload)}\n\n"
-
                 yield "data: [DONE]\n\n"
 
             except Exception as e:
 
-                logger.error(f"Streaming error: {e}")
+                logger.error(f"Stream generation error: {e}")
 
                 error_payload = {
                     "error": {
@@ -281,7 +727,8 @@ async def chat_completions(
             headers={
                 "Cache-Control": "no-cache",
                 "Connection": "keep-alive",
-                "X-Accel-Buffering": "no"
+                "X-Accel-Buffering": "no",
+                "Transfer-Encoding": "chunked"
             }
         )
 
@@ -291,26 +738,36 @@ async def chat_completions(
 
     try:
 
-        client = Client()
+        proxy = get_proxy()
 
-        response = await asyncio.to_thread(
-            client.chat.completions.create,
+        response, actual_model = await smart_completion(
             model=body.model,
-            messages=messages
+            messages=messages,
+            stream=False,
+            max_retries=3,
+            proxy=proxy
         )
 
+        # استخراج المحتوى
         assistant_message = ""
 
         try:
-            assistant_message = response.choices[0].message.content
-        except:
-            assistant_message = str(response)
+            assistant_message = response.choices[0].message.content or ""
+        except AttributeError:
+            try:
+                assistant_message = str(response)
+            except Exception:
+                assistant_message = "Error extracting response"
+
+        # حساب الرموز تقريبياً
+        prompt_tokens = sum(len(m["content"].split()) for m in messages)
+        completion_tokens = len(assistant_message.split())
 
         return JSONResponse({
             "id": f"chatcmpl-{uuid.uuid4().hex}",
             "object": "chat.completion",
             "created": int(time.time()),
-            "model": body.model,
+            "model": actual_model,
             "choices": [
                 {
                     "index": 0,
@@ -322,19 +779,26 @@ async def chat_completions(
                 }
             ],
             "usage": {
-                "prompt_tokens": 0,
-                "completion_tokens": 0,
-                "total_tokens": 0
+                "prompt_tokens": prompt_tokens,
+                "completion_tokens": completion_tokens,
+                "total_tokens": prompt_tokens + completion_tokens
             }
         })
 
+    except HTTPException:
+        raise
+
     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"
+            }
         )
 
 # =====================================================
@@ -345,8 +809,13 @@ 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(f"📦 Models configured: {len(MODEL_PROVIDER_MAP)}")
+
     uvicorn.run(
         app,
         host="0.0.0.0",
-        port=7860
-    )
+        port=7860,
+        log_level="info"
+    )