Update app.py

app.py

@@ -2,21 +2,33 @@ 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
+from enum import Enum
 
 import g4f
 from g4f.client import Client
+from g4f.Provider import (
+    BingCreateImage,
+    OpenaiChat,
+    Claude,
+    Blackbox,
+    DeepInfra,
+    PerplexityLabs
+)
 
 # =====================================================
 # LOGGING
 # =====================================================
 
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
 logger = logging.getLogger(__name__)
 
 # =====================================================
@@ -24,14 +36,34 @@ logger = logging.getLogger(__name__)
 # =====================================================
 
 API_KEY = "sk-your-secret-key"
+REQUEST_TIMEOUT = 120
+MAX_RETRIES = 3
+
+# =====================================================
+# PROVIDERS MAPPING
+# =====================================================
+
+PROVIDERS_MAP: Dict[str, type] = {
+    "gpt-4o": Blackbox,
+    "gpt-4o-mini": DeepInfra,
+    "gpt-4": Claude,
+    "claude-3-haiku": Claude,
+    "claude-3-sonnet": Claude,
+    "llama-3.1-70b": DeepInfra,
+    "mixtral-8x7b": DeepInfra,
+    "deepseek-chat": Blackbox,
+    "perplexity-chat": PerplexityLabs,
+}
 
 # =====================================================
 # FASTAPI
 # =====================================================
 
 app = FastAPI(
-    title="Universal AI Gateway",
-    version="4.0.0"
+    title="Universal AI Gateway Pro",
+    version="5.0.0",
+    docs_url="/docs",
+    openapi_url="/openapi.json"
 )
 
 # =====================================================
@@ -59,191 +91,269 @@ class ChatRequest(BaseModel):
     messages: List[Message]
     stream: bool = False
     temperature: Optional[float] = 0.7
-    max_tokens: Optional[int] = 4096
+    max_tokens: Optional[int] = 2048
+    top_p: Optional[float] = 1.0
+
+class ErrorResponse(BaseModel):
+    error: Dict[str, str]
 
 # =====================================================
 # AUTH
 # =====================================================
 
-def verify_api_key(req: Request):
-
+def verify_api_key(req: Request) -> bool:
+    """التحقق من مفتاح API"""
+    
     auth = req.headers.get("Authorization")
-
-    # السماح للاختبار
+    
+    # السماح للاختبار بدون مفتاح
     if not auth:
+        logger.warning("Request without API key detected")
         return True
-
+    
     if not auth.startswith("Bearer "):
         raise HTTPException(
             status_code=401,
-            detail="Invalid Authorization Format"
+            detail="Invalid Authorization Format. Use: Bearer <token>"
         )
-
+    
     token = auth.replace("Bearer ", "").strip()
-
+    
     if token != API_KEY:
         raise HTTPException(
             status_code=403,
             detail="Invalid API Key"
         )
-
+    
     return True
 
 # =====================================================
-# ROOT
+# HELPER FUNCTIONS
+# =====================================================
+
+def get_provider_for_model(model: str) -> type:
+    """الحصول على المزود المناسب للنموذج"""
+    
+    provider = PROVIDERS_MAP.get(model, DeepInfra)
+    logger.info(f"Using provider {provider.__name__} for model {model}")
+    return provider
+
+async def create_chat_client(model: str) -> Client:
+    """إنشاء عميل محسّن مع المزود المناسب"""
+    
+    provider = get_provider_for_model(model)
+    
+    try:
+        client = Client(
+            provider=provider,
+            timeout=REQUEST_TIMEOUT,
+            max_retries=MAX_RETRIES
+        )
+        return client
+    except Exception as e:
+        logger.error(f"Failed to create client for {model}: {e}")
+        # fallback to default client
+        return Client()
+
+def format_messages(messages: List[Message]) -> List[Dict]:
+    """تنسيق الرسائل للإرسال"""
+    
+    return [
+        {
+            "role": m.role,
+            "content": m.content
+        }
+        for m in messages
+    ]
+
+async def create_completion_with_retry(
+    client: Client,
+    model: str,
+    messages: List[Dict],
+    stream: bool = False,
+    temperature: float = 0.7,
+    max_tokens: int = 2048
+) -> any:
+    """إنشاء استجابة مع إعادة محاولة"""
+    
+    retries = 0
+    last_error = None
+    
+    while retries < MAX_RETRIES:
+        try:
+            response = await asyncio.to_thread(
+                client.chat.completions.create,
+                model=model,
+                messages=messages,
+                stream=stream,
+                temperature=temperature,
+                max_tokens=max_tokens
+            )
+            return response
+            
+        except Exception as e:
+            last_error = e
+            retries += 1
+            logger.warning(
+                f"Attempt {retries}/{MAX_RETRIES} failed: {e}"
+            )
+            
+            if retries < MAX_RETRIES:
+                await asyncio.sleep(2 ** retries)  # exponential backoff
+            else:
+                raise last_error
+
+# =====================================================
+# ENDPOINTS
 # =====================================================
 
 @app.get("/")
 async def root():
-
+    """جذر API - معلومات الخدمة"""
+    
     return {
         "status": "online",
-        "service": "Universal AI Gateway",
-        "version": "4.0.0"
+        "service": "Universal AI Gateway Pro",
+        "version": "5.0.0",
+        "providers": list(PROVIDERS_MAP.keys()),
+        "documentation": "/docs"
     }
 
-# =====================================================
-# MODELS
-# =====================================================
-
 @app.get("/v1/models")
 async def get_models():
-
+    """قائمة النماذج المتاحة"""
+    
     models_data = []
-
-    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"
-    ]
-
-    try:
-
-        if hasattr(g4f.models, "_all_models"):
-
-            all_models = list(g4f.models._all_models)
-
-            for model in all_models[:50]:
-
-                models_data.append({
-                    "id": str(model),
-                    "object": "model",
-                    "created": int(time.time()),
-                    "owned_by": "g4f"
-                })
-
-    except Exception as e:
-
-        logger.error(f"Models error: {e}")
-
-    # fallback
-    if not models_data:
-
-        for model in fallback_models:
-
-            models_data.append({
-                "id": model,
-                "object": "model",
-                "created": int(time.time()),
-                "owned_by": "g4f"
-            })
-
+    
+    # النماذج المدعومة مع مزودين حقيقيين
+    supported_models = {
+        "gpt-4o": "Blackbox",
+        "gpt-4o-mini": "DeepInfra",
+        "gpt-4": "Claude",
+        "claude-3-haiku": "Claude",
+        "claude-3-sonnet": "Claude",
+        "llama-3.1-70b": "DeepInfra",
+        "mixtral-8x7b": "DeepInfra",
+        "deepseek-chat": "Blackbox",
+        "perplexity-chat": "PerplexityLabs",
+    }
+    
+    for model_id, provider_name in supported_models.items():
+        models_data.append({
+            "id": model_id,
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": provider_name,
+            "provider": provider_name,
+            "active": True
+        })
+    
+    logger.info(f"Returning {len(models_data)} available models")
+    
     return {
         "object": "list",
         "data": models_data
     }
 
-# =====================================================
-# CHAT COMPLETIONS
-# =====================================================
-
-@app.post("/v1/chat/completions")
-async def chat_completions(
-    req: Request,
-    body: ChatRequest
-):
+@app.get("/v1/models/{model_id}")
+async def get_model_info(model_id: str):
+    """معلومات نموذج محدد"""
+    
+    if model_id not in PROVIDERS_MAP:
+        raise HTTPException(
+            status_code=404,
+            detail=f"Model {model_id} not found"
+        )
+    
+    provider = PROVIDERS_MAP[model_id]
+    
+    return {
+        "id": model_id,
+        "object": "model",
+        "created": int(time.time()),
+        "owned_by": provider.__name__,
+        "provider": provider.__name__,
+        "active": True
+    }
 
+@app.post("/v1/chat/completions", response_class=StreamingResponse)
+async def chat_completions(req: Request, body: ChatRequest):
+    """استكمال المحادثات - متوافق مع OpenAI API"""
+    
+    # التحقق من المفتاح
     verify_api_key(req)
-
-    messages = [
-        {
-            "role": m.role,
-            "content": m.content
-        }
-        for m in body.messages
-    ]
-
+    
+    # تنسيق الرسائل
+    messages = format_messages(body.messages)
+    
     logger.info(
-        f"Request model={body.model} stream={body.stream}"
+        f"Chat request - Model: {body.model}, "
+        f"Stream: {body.stream}, "
+        f"Messages: {len(messages)}"
     )
-
-    # =================================================
-    # STREAMING
-    # =================================================
-
+    
+    # إنشاء العميل
+    client = await create_chat_client(body.model)
+    
+    # =========================================================
+    # STREAMING RESPONSE
+    # =========================================================
+    
     if body.stream:
-
+        
         async def generate_stream():
-
+            """��ولّد الدفق المتدفق"""
+            
+            chunk_id = f"chatcmpl-{uuid.uuid4().hex}"
+            
             try:
-
-                client = Client()
-
-                response = client.chat.completions.create(
+                # الحصول على الاستجابة المتدفقة
+                response = await create_completion_with_retry(
+                    client=client,
                     model=body.model,
                     messages=messages,
-                    stream=True
+                    stream=True,
+                    temperature=body.temperature,
+                    max_tokens=body.max_tokens
                 )
-
-                chunk_id = f"chatcmpl-{uuid.uuid4().hex}"
-
+                
+                # إرسال الأجزاء
                 for chunk in response:
-
                     try:
-
                         content = ""
-
-                        if (
-                            chunk.choices
-                            and chunk.choices[0].delta
-                            and chunk.choices[0].delta.content
-                        ):
-                            content = chunk.choices[0].delta.content
-
-                        if content:
-
-                            payload = {
-                                "id": chunk_id,
-                                "object": "chat.completion.chunk",
-                                "created": int(time.time()),
-                                "model": body.model,
-                                "choices": [
-                                    {
-                                        "index": 0,
-                                        "delta": {
-                                            "content": content
-                                        },
-                                        "finish_reason": None
-                                    }
-                                ]
-                            }
-
-                            yield f"data: {json.dumps(payload)}\n\n"
-
-                            await asyncio.sleep(0)
-
+                        finish_reason = None
+                        
+                        # استخراج المحتوى من الجزء
+                        if hasattr(chunk, 'choices') and chunk.choices:
+                            if hasattr(chunk.choices[0], 'delta'):
+                                if chunk.choices[0].delta.content:
+                                    content = chunk.choices[0].delta.content
+                            if hasattr(chunk.choices[0], 'finish_reason'):
+                                finish_reason = chunk.choices[0].finish_reason
+                        
+                        # إنشاء payload
+                        payload = {
+                            "id": chunk_id,
+                            "object": "chat.completion.chunk",
+                            "created": int(time.time()),
+                            "model": body.model,
+                            "choices": [
+                                {
+                                    "index": 0,
+                                    "delta": {"content": content} if content else {},
+                                    "finish_reason": finish_reason
+                                }
+                            ]
+                        }
+                        
+                        yield f"data: {json.dumps(payload)}\n\n"
+                        await asyncio.sleep(0.01)  # تحسين الاستجابة
+                        
                     except Exception as chunk_error:
-
-                        logger.error(
-                            f"Chunk error: {chunk_error}"
-                        )
-
+                        logger.error(f"Chunk processing error: {chunk_error}")
+                        continue
+                
+                # إرسال الحزمة النهائية
                 final_payload = {
                     "id": chunk_id,
                     "object": "chat.completion.chunk",
@@ -257,24 +367,23 @@ async def chat_completions(
                         }
                     ]
                 }
-
-                yield f"data: {json.dumps(final_payload)}\n\n"
-
-                yield "data: [DONE]\n\n"
-
+                
+                yield f for {body.model}")
+                
             except Exception as e:
-
-                logger.error(f"Streaming error: {e}")
-
+                logger.error(f"Streaming error: {e}", exc_info=True)
+                
                 error_payload = {
                     "error": {
                         "message": str(e),
-                        "type": "server_error"
+                        "type": "server_error",
+                        "param": None,
+                        "code": "server_error"
                     }
                 }
-
+                
                 yield f"data: {json.dumps(error_payload)}\n\n"
-
+        
         return StreamingResponse(
             generate_stream(),
             media_type="text/event-stream",
@@ -284,28 +393,45 @@ async def chat_completions(
                 "X-Accel-Buffering": "no"
             }
         )
-
-    # =================================================
-    # NORMAL RESPONSE
-    # =================================================
-
+    
+    # =========================================================
+    # NORMAL (NON-STREAMING) RESPONSE
+    # =========================================================
+    
     try:
-
-        client = Client()
-
-        response = await asyncio.to_thread(
-            client.chat.completions.create,
+        response = await create_completion_with_retry(
+            client=client,
             model=body.model,
-            messages=messages
+            messages=messages,
+            stream=False,
+            temperature=body.temperature,
+            max_tokens=body.max_tokens
         )
-
+        
         assistant_message = ""
-
+        completion_tokens = 0
+        
         try:
-            assistant_message = response.choices[0].message.content
-        except:
+            if hasattr(response, 'choices') and response.choices:
+                if hasattr(response.choices[0], 'message'):
+                    assistant_message = response.choices[0].message.content
+                else:
+                    assistant_message = str(response)
+            else:
+                assistant_message = str(response)
+        except Exception as parse_error:
+            logger.error(f"Response parsing error: {parse_error}")
             assistant_message = str(response)
-
+        
+        # حساب التقريبي للـ tokens
+        completion_tokens = len(assistant_message.split()) * 1.3
+        prompt_tokens = sum(len(m["content"].split()) * 1.3 for m in messages)
+        
+        logger.info(
+            f"Completion successful - Model: {body.model}, "
+            f"Tokens: {prompt_tokens + completion_tokens}"
+        )
+        
         return JSONResponse({
             "id": f"chatcmpl-{uuid.uuid4().hex}",
             "object": "chat.completion",
@@ -322,31 +448,66 @@ async def chat_completions(
                 }
             ],
             "usage": {
-                "prompt_tokens": 0,
-                "completion_tokens": 0,
-                "total_tokens": 0
+                "prompt_tokens": int(prompt_tokens),
+                "completion_tokens": int(completion_tokens),
+                "total_tokens": int(prompt_tokens + completion_tokens)
             }
         })
-
+        
     except Exception as e:
-
-        logger.error(f"Chat error: {e}")
-
+        logger.error(f"Chat completion error: {e}", exc_info=True)
+        
         raise HTTPException(
             status_code=500,
-            detail=str(e)
+            detail={
+                "message": str(e),
+                "type": "server_error",
+                "model": body.model
+            }
         )
 
+@app.get("/v1/health")
+async def health_check():
+    """فحص صحة الخدمة"""
+    
+    return {
+        "status": "healthy",
+        "timestamp": int(time.time()),
+        "version": "5.0.0"
+    }
+
+# =====================================================
+# ERROR HANDLERS
+# =====================================================
+
+@app.exception_handler(HTTPException)
+async def http_exception_handler(request: Request, exc: HTTPException):
+    """معالج استثناءات HTTP"""
+    
+    return JSONResponse(
+        status_code=exc.status_code,
+        content={
+            "error": {
+                "message": exc.detail,
+                "type": "http_error",
+                "status_code": exc.status_code
+            }
+        }
+    )
+
 # =====================================================
 # RUN
 # =====================================================
 
 if __name__ == "__main__":
-
     import uvicorn
-
+    
+    logger.info("Starting Universal AI Gateway Pro v5.0.0")
+    logger.info(f"Available providers: {list(PROVIDERS_MAP.keys())}")
+    
     uvicorn.run(
         app,
         host="0.0.0.0",
-        port=7860
-    )
+        port=7860,
+        log_level="info"
+    )