Update app.py

app.py

@@ -10,6 +10,7 @@ import uuid
 import logging
 
 import g4f
+import g4f.models
 from g4f.client import Client
 
 # =====================================================
@@ -17,6 +18,7 @@ from g4f.client import Client
 # =====================================================
 
 logging.basicConfig(level=logging.INFO)
+
 logger = logging.getLogger(__name__)
 
 # =====================================================
@@ -31,7 +33,7 @@ API_KEY = "sk-your-secret-key"
 
 app = FastAPI(
     title="Universal AI Gateway",
-    version="5.0.0"
+    version="4.0.0"
 )
 
 # =====================================================
@@ -47,20 +49,22 @@ app.add_middleware(
 )
 
 # =====================================================
-# REQUEST MODELS
+# MODELS
 # =====================================================
 
 class Message(BaseModel):
     role: str
     content: str
 
+
 class ChatRequest(BaseModel):
     model: str
     messages: List[Message]
-    stream: bool = False
+    stream: Optional[bool] = False
     temperature: Optional[float] = 0.7
     max_tokens: Optional[int] = 4096
 
+
 # =====================================================
 # AUTH
 # =====================================================
@@ -69,9 +73,11 @@ def verify_api_key(req: Request):
 
     auth = req.headers.get("Authorization")
 
-    # السماح بالاختبار
     if not auth:
-        return True
+        raise HTTPException(
+            status_code=401,
+            detail="Missing Authorization Header"
+        )
 
     if not auth.startswith("Bearer "):
         raise HTTPException(
@@ -79,7 +85,7 @@ def verify_api_key(req: Request):
             detail="Invalid Authorization Format"
         )
 
-    token = auth.replace("Bearer ", "").strip()
+    token = auth.replace("Bearer ", "")
 
     if token != API_KEY:
         raise HTTPException(
@@ -87,138 +93,99 @@ def verify_api_key(req: Request):
             detail="Invalid API Key"
         )
 
-    return True
 
 # =====================================================
-# PROVIDERS
+# ROOT
 # =====================================================
 
-def get_provider(provider_name):
-
-    providers_map = {}
-
-    # Duck.ai
-    if hasattr(g4f.Provider, "DuckDuckGo"):
-        providers_map["duck"] = g4f.Provider.DuckDuckGo
-        providers_map["duckduckgo"] = g4f.Provider.DuckDuckGo
-
-    # Blackbox
-    if hasattr(g4f.Provider, "Blackbox"):
-        providers_map["blackbox"] = g4f.Provider.Blackbox
-
-    # Free2GPT
-    if hasattr(g4f.Provider, "Free2GPT"):
-        providers_map["free2gpt"] = g4f.Provider.Free2GPT
-
-    # Copilot
-    if hasattr(g4f.Provider, "Copilot"):
-        providers_map["copilot"] = g4f.Provider.Copilot
-
-    # Liaobots
-    if hasattr(g4f.Provider, "Liaobots"):
-        providers_map["liaobots"] = g4f.Provider.Liaobots
-
-    # Gemini
-    if hasattr(g4f.Provider, "Gemini"):
-        providers_map["gemini"] = g4f.Provider.Gemini
-
-    # DeepInfra
-    if hasattr(g4f.Provider, "DeepInfra"):
-        providers_map["deepinfra"] = g4f.Provider.DeepInfra
+@app.get("/")
+async def root():
 
-    # Pollinations
-    if hasattr(g4f.Provider, "PollinationsAI"):
-        providers_map["pollinations"] = g4f.Provider.PollinationsAI
+    return {
+        "status": "online",
+        "service": "Universal AI Gateway",
+        "version": "4.0.0"
+    }
 
-    return providers_map.get(provider_name.lower())
 
 # =====================================================
-# MODEL ROUTING
+# AUTO MODELS IMPORT
 # =====================================================
 
-def detect_provider(model_name: str):
+@app.get("/v1/models")
+async def get_models():
 
-    model = model_name.lower()
+    models_data = []
 
-    # GPT Models -> Duck.ai أولاً
-    if "gpt" in model:
-        return "duck"
+    try:
 
-    # Claude
-    if "claude" in model:
-        return "liaobots"
+        all_models = []
 
-    # Gemini
-    if "gemini" in model:
-        return "gemini"
+        if hasattr(g4f.models, "_all_models"):
+            all_models = list(g4f.models._all_models)
 
-    # DeepSeek
-    if "deepseek" in model:
-        return "deepinfra"
+        elif hasattr(g4f.models, "__models__"):
+            all_models = list(g4f.models.__models__)
 
-    # Llama
-    if "llama" in model:
-        return "deepinfra"
+        unique_models = set()
 
-    # Mixtral
-    if "mixtral" in model:
-        return "deepinfra"
+        for model in all_models:
 
-    # fallback
-    return "duck"
+            model_name = str(model)
 
-# =====================================================
-# ROOT
-# =====================================================
+            if model_name not in unique_models:
 
-@app.get("/")
-async def root():
-
-    return {
-        "status": "online",
-        "service": "Universal AI Gateway",
-        "version": "5.0.0",
-        "g4f": True,
-        "duck_ai": True
-    }
-
-# =====================================================
-# MODELS
-# =====================================================
-
-@app.get("/v1/models")
-async def get_models():
+                unique_models.add(model_name)
 
-    fallback_models = [
-        "gpt-4o-mini",
-        "gpt-4o",
-        "gpt-4",
-        "gpt-3.5-turbo",
-        "claude-3-haiku",
-        "claude-3-sonnet",
-        "gemini-pro",
-        "gemini-1.5-flash",
-        "llama-3.1-70b",
-        "mixtral-8x7b",
-        "deepseek-chat"
-    ]
+                models_data.append({
+                    "id": model_name,
+                    "object": "model",
+                    "created": int(time.time()),
+                    "owned_by": "g4f"
+                })
+
+        if not models_data:
+
+            fallback_models = [
+                "gpt-4o-mini",
+                "gpt-4o",
+                "gpt-4",
+                "gpt-3.5-turbo",
+                "claude-3-haiku",
+                "claude-3-opus",
+                "gemini-pro",
+                "llama-3.1-70b",
+                "mixtral-8x7b"
+            ]
+
+            for model_name in fallback_models:
+
+                models_data.append({
+                    "id": model_name,
+                    "object": "model",
+                    "created": int(time.time()),
+                    "owned_by": "g4f"
+                })
 
-    models_data = []
+    except Exception as e:
 
-    for model in fallback_models:
+        logger.error(f"Models error: {e}")
 
-        models_data.append({
-            "id": model,
-            "object": "model",
-            "created": int(time.time()),
-            "owned_by": "g4f"
-        })
+        models_data = [
+            {
+                "id": "gpt-4o-mini",
+                "object": "model",
+                "created": int(time.time()),
+                "owned_by": "g4f"
+            }
+        ]
 
     return {
         "object": "list",
         "data": models_data
     }
 
+
 # =====================================================
 # CHAT COMPLETIONS
 # =====================================================
@@ -239,16 +206,10 @@ async def chat_completions(
         for m in body.messages
     ]
 
-    provider_name = detect_provider(body.model)
-
-    provider = get_provider(provider_name)
-
-    logger.info(
-        f"MODEL={body.model} | PROVIDER={provider_name}"
-    )
+    logger.info(f"Request model: {body.model}")
 
     # =================================================
-    # STREAM
+    # STREAM MODE
     # =================================================
 
     if body.stream:
@@ -261,7 +222,6 @@ async def chat_completions(
 
                 response = client.chat.completions.create(
                     model=body.model,
-                    provider=provider,
                     messages=messages,
                     stream=True
                 )
@@ -303,9 +263,9 @@ async def chat_completions(
 
                             await asyncio.sleep(0)
 
-                    except Exception as e:
+                    except Exception as chunk_error:
 
-                        logger.error(f"Chunk Error: {e}")
+                        logger.error(f"Chunk error: {chunk_error}")
 
                 final_payload = {
                     "id": chunk_id,
@@ -327,7 +287,7 @@ async def chat_completions(
 
             except Exception as e:
 
-                logger.error(f"Streaming Error: {e}")
+                logger.error(f"Streaming error: {e}")
 
                 error_payload = {
                     "error": {
@@ -349,7 +309,7 @@ async def chat_completions(
         )
 
     # =================================================
-    # NORMAL
+    # NORMAL RESPONSE
     # =================================================
 
     try:
@@ -359,7 +319,6 @@ async def chat_completions(
         response = await asyncio.to_thread(
             client.chat.completions.create,
             model=body.model,
-            provider=provider,
             messages=messages
         )
 
@@ -394,25 +353,26 @@ async def chat_completions(
 
     except Exception as e:
 
-        logger.error(f"Chat Error: {e}")
+        logger.error(f"Chat error: {e}")
 
         raise HTTPException(
             status_code=500,
             detail=str(e)
         )
 
+
 # =====================================================
-# HEALTH
+# TEST UI
 # =====================================================
 
-@app.get("/health")
-async def health():
+@app.get("/test")
+async def test():
 
     return {
-        "ok": True,
-        "time": int(time.time())
+        "message": "Server is working"
     }
 
+
 # =====================================================
 # RUN
 # =====================================================
@@ -421,6 +381,8 @@ if __name__ == "__main__":
 
     import uvicorn
 
+    print("Server running on port 7860")
+
     uvicorn.run(
         app,
         host="0.0.0.0",