Update app.py

app.py

@@ -2,33 +2,27 @@ 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, Dict
+from typing import List, Optional
 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
+    PerplexityLabs,
+    HuggingChat
 )
 
 # =====================================================
 # LOGGING
 # =====================================================
 
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 # =====================================================
@@ -36,23 +30,21 @@ logger = logging.getLogger(__name__)
 # =====================================================
 
 API_KEY = "sk-your-secret-key"
-REQUEST_TIMEOUT = 120
-MAX_RETRIES = 3
 
 # =====================================================
-# PROVIDERS MAPPING
+# PROVIDER MAPPING - التعديل الدقيق #1
 # =====================================================
 
-PROVIDERS_MAP: Dict[str, type] = {
+REAL_PROVIDERS = {
     "gpt-4o": Blackbox,
     "gpt-4o-mini": DeepInfra,
-    "gpt-4": Claude,
-    "claude-3-haiku": Claude,
-    "claude-3-sonnet": Claude,
+    "gpt-4": Blackbox,
+    "gpt-3.5-turbo": DeepInfra,
+    "claude-3-haiku": HuggingChat,
     "llama-3.1-70b": DeepInfra,
     "mixtral-8x7b": DeepInfra,
     "deepseek-chat": Blackbox,
-    "perplexity-chat": PerplexityLabs,
+    "gemini-pro": PerplexityLabs
 }
 
 # =====================================================
@@ -60,10 +52,8 @@ PROVIDERS_MAP: Dict[str, type] = {
 # =====================================================
 
 app = FastAPI(
-    title="Universal AI Gateway Pro",
-    version="5.0.0",
-    docs_url="/docs",
-    openapi_url="/openapi.json"
+    title="Universal AI Gateway",
+    version="4.0.0"
 )
 
 # =====================================================
@@ -91,269 +81,196 @@ class ChatRequest(BaseModel):
     messages: List[Message]
     stream: bool = False
     temperature: Optional[float] = 0.7
-    max_tokens: Optional[int] = 2048
-    top_p: Optional[float] = 1.0
-
-class ErrorResponse(BaseModel):
-    error: Dict[str, str]
+    max_tokens: Optional[int] = 4096
 
 # =====================================================
 # AUTH
 # =====================================================
 
-def verify_api_key(req: Request) -> bool:
-    """التحقق من مفتاح API"""
-    
+def verify_api_key(req: Request):
+
     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. Use: Bearer <token>"
+            detail="Invalid Authorization Format"
         )
-    
+
     token = auth.replace("Bearer ", "").strip()
-    
+
     if token != API_KEY:
         raise HTTPException(
             status_code=403,
             detail="Invalid API Key"
         )
-    
-    return True
-
-# =====================================================
-# 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
+    return True
 
 # =====================================================
-# ENDPOINTS
+# ROOT
 # =====================================================
 
 @app.get("/")
 async def root():
-    """جذر API - معلومات الخدمة"""
-    
+
     return {
         "status": "online",
-        "service": "Universal AI Gateway Pro",
-        "version": "5.0.0",
-        "providers": list(PROVIDERS_MAP.keys()),
-        "documentation": "/docs"
+        "service": "Universal AI Gateway",
+        "version": "4.0.0"
     }
 
+# =====================================================
+# MODELS
+# =====================================================
+
 @app.get("/v1/models")
 async def get_models():
-    """قائمة النماذج المتاحة"""
-    
+
     models_data = []
-    
-    # النماذج المدعومة مع مزودين حقيقيين
-    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")
-    
+
+    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 - التعديل الدقيق #2
+    if not models_data:
+
+        for model in fallback_models:
+            provider_name = "g4f"
+            if model in REAL_PROVIDERS:
+                provider_name = REAL_PROVIDERS[model].__name__
+            
+            models_data.append({
+                "id": model,
+                "object": "model",
+                "created": int(time.time()),
+                "owned_by": provider_name
+            })
+
     return {
         "object": "list",
         "data": models_data
     }
 
-@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
-    }
+# =====================================================
+# CHAT COMPLETIONS
+# =====================================================
+
+@app.post("/v1/chat/completions")
+async def chat_completions(
+    req: Request,
+    body: ChatRequest
+):
 
-@app.post("/v1/chat/completions", response_class=StreamingResponse)
-async def chat_completions(req: Request, body: ChatRequest):
-    """استكمال المحادثات - متوافق مع OpenAI API"""
-    
-    # التحقق من المفتاح
     verify_api_key(req)
-    
-    # تنسيق الرسائل
-    messages = format_messages(body.messages)
-    
+
+    messages = [
+        {
+            "role": m.role,
+            "content": m.content
+        }
+        for m in body.messages
+    ]
+
     logger.info(
-        f"Chat request - Model: {body.model}, "
-        f"Stream: {body.stream}, "
-        f"Messages: {len(messages)}"
+        f"Request model={body.model} stream={body.stream}"
     )
-    
-    # إنشاء العميل
-    client = await create_chat_client(body.model)
-    
-    # =========================================================
-    # STREAMING RESPONSE
-    # =========================================================
-    
+
+    # =================================================
+    # STREAMING
+    # =================================================
+
     if body.stream:
-        
+
         async def generate_stream():
-            """مولّد الدفق المتدفق"""
-            
-            chunk_id = f"chatcmpl-{uuid.uuid4().hex}"
-            
+
             try:
-                # الحصول على الاستجابة المتدفقة
-                response = await create_completion_with_retry(
-                    client=client,
+
+                # التعديل الدقيق #3 - استخدام المزود الحقيقي
+                provider = REAL_PROVIDERS.get(body.model, None)
+                client = Client(provider=provider) if provider else Client()
+
+                response = client.chat.completions.create(
                     model=body.model,
                     messages=messages,
-                    stream=True,
-                    temperature=body.temperature,
-                    max_tokens=body.max_tokens
+                    stream=True
                 )
-                
-                # إرسال الأجزاء
+
+                chunk_id = f"chatcmpl-{uuid.uuid4().hex}"
+
                 for chunk in response:
+
                     try:
+
                         content = ""
-                        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)  # تحسين الاستجابة
-                        
+
+                        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)
+
                     except Exception as chunk_error:
-                        logger.error(f"Chunk processing error: {chunk_error}")
-                        continue
-                
-                # إرسال الحزمة النهائية
+
+                        logger.error(
+                            f"Chunk error: {chunk_error}"
+                        )
+
                 final_payload = {
                     "id": chunk_id,
                     "object": "chat.completion.chunk",
@@ -367,23 +284,16 @@ async def chat_completions(req: Request, body: ChatRequest):
                         }
                     ]
                 }
-                
-                yield f for {body.model}")
-                
-            except Exception as e:
-                logger.error(f"Streaming error: {e}", exc_info=True)
-                
-                error_payload = {
+
+                yield f"data: {json.dumps(final_payload)}\n\error_payload = {
                     "error": {
                         "message": str(e),
-                        "type": "server_error",
-                        "param": None,
-                        "code": "server_error"
+                        "type": "server_error"
                     }
                 }
-                
+
                 yield f"data: {json.dumps(error_payload)}\n\n"
-        
+
         return StreamingResponse(
             generate_stream(),
             media_type="text/event-stream",
@@ -393,45 +303,30 @@ async def chat_completions(req: Request, body: ChatRequest):
                 "X-Accel-Buffering": "no"
             }
         )
-    
-    # =========================================================
-    # NORMAL (NON-STREAMING) RESPONSE
-    # =========================================================
-    
+
+    # =================================================
+    # NORMAL RESPONSE
+    # =================================================
+
     try:
-        response = await create_completion_with_retry(
-            client=client,
+
+        # التعديل الدقيق #4 - استخدام المزود الحقيقي
+        provider = REAL_PROVIDERS.get(body.model, None)
+        client = Client(provider=provider) if provider else Client()
+
+        response = await asyncio.to_thread(
+            client.chat.completions.create,
             model=body.model,
-            messages=messages,
-            stream=False,
-            temperature=body.temperature,
-            max_tokens=body.max_tokens
+            messages=messages
         )
-        
+
         assistant_message = ""
-        completion_tokens = 0
-        
+
         try:
-            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 = response.choices[0].message.content
+        except:
             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",
@@ -448,66 +343,31 @@ async def chat_completions(req: Request, body: ChatRequest):
                 }
             ],
             "usage": {
-                "prompt_tokens": int(prompt_tokens),
-                "completion_tokens": int(completion_tokens),
-                "total_tokens": int(prompt_tokens + completion_tokens)
+                "prompt_tokens": 0,
+                "completion_tokens": 0,
+                "total_tokens": 0
             }
         })
-        
+
     except Exception as e:
-        logger.error(f"Chat completion error: {e}", exc_info=True)
-        
+
+        logger.error(f"Chat error: {e}")
+
         raise HTTPException(
             status_code=500,
-            detail={
-                "message": str(e),
-                "type": "server_error",
-                "model": body.model
-            }
+            detail=str(e)
         )
 
-@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,
-        log_level="info"
+        port=7860
     )