Update app.py

app.py

@@ -1,14 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
 import time
 import random
 import traceback
 import logging
 
 from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 import uvicorn
 
 from g4f.client import Client
-from g4f.Provider import __providers__
+
+# =====================================================
+# IMPORT SAFE PROVIDERS ONLY
+# =====================================================
+
+import g4f.Provider as Provider
 
 # =====================================================
 # CONFIG
@@ -38,36 +47,57 @@ logger = logging.getLogger("smart-g4f")
 
 app = FastAPI(
     title="Smart G4F Gateway",
-    version="1.1"
+    version="2.0"
 )
 
 # =====================================================
-# AUTH
+# CORS
+# =====================================================
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# =====================================================
+# API KEY AUTH
 # =====================================================
 
 def verify_api_key(req: Request):
 
+    # =========================================
+    # Authorization: Bearer
+    # =========================================
+
     auth = req.headers.get("Authorization")
 
-    if not auth:
-        raise HTTPException(
-            status_code=401,
-            detail="Missing Authorization Header"
-        )
+    if auth and auth.startswith("Bearer "):
 
-    if not auth.startswith("Bearer "):
-        raise HTTPException(
-            status_code=401,
-            detail="Invalid Authorization Format"
-        )
+        token = auth.replace("Bearer ", "").strip()
 
-    token = auth.replace("Bearer ", "").strip()
+        if token == API_KEY:
+            return True
 
-    if token != API_KEY:
-        raise HTTPException(
-            status_code=403,
-            detail="Invalid API Key"
-        )
+    # =========================================
+    # x-api-key
+    # =========================================
+
+    x_api_key = req.headers.get("x-api-key")
+
+    if x_api_key and x_api_key.strip() == API_KEY:
+        return True
+
+    # =========================================
+    # FAILED
+    # =========================================
+
+    raise HTTPException(
+        status_code=403,
+        detail="Invalid API Key"
+    )
 
 # =====================================================
 # SAFE PROVIDERS
@@ -75,41 +105,35 @@ def verify_api_key(req: Request):
 
 SAFE_PROVIDERS = []
 
-for provider in __providers__:
-
-    try:
-
-        name = provider.__name__.lower()
-
-        if not getattr(provider, "working", False):
-            continue
+PREFERRED = [
+    ("Blackbox", "blackboxai"),
+    ("Free2GPT", "gpt-4o-mini"),
+    ("DuckDuckGo", "gpt-4o-mini"),
+]
 
-        if getattr(provider, "needs_auth", False):
-            continue
+for provider_name, provider_model in PREFERRED:
 
-        if getattr(provider, "use_nodriver", False):
-            continue
+    try:
 
-        blocked = [
-            "openai",
-            "qwen",
-            "copilot",
-            "gemini",
-            "claude",
-        ]
+        provider = getattr(Provider, provider_name)
 
-        if any(x in name for x in blocked):
-            continue
+        SAFE_PROVIDERS.append({
+            "provider": provider,
+            "model": provider_model
+        })
 
-        SAFE_PROVIDERS.append(provider)
+    except Exception as e:
 
-    except Exception:
-        continue
+        logger.warning(f"Provider load failed: {provider_name} -> {e}")
 
 random.shuffle(SAFE_PROVIDERS)
 
 logger.info(f"[+] SAFE PROVIDERS: {len(SAFE_PROVIDERS)}")
 
+# =====================================================
+# CLIENT
+# =====================================================
+
 client = Client()
 
 # =====================================================
@@ -120,13 +144,16 @@ class SmartG4F:
 
     def __init__(self):
 
-        self.good = []
         self.bad = {}
 
+    # =================================================
+
     def mark_bad(self, provider, cooldown=300):
 
         self.bad[provider.__name__] = time.time() + cooldown
 
+    # =================================================
+
     def is_bad(self, provider):
 
         if provider.__name__ not in self.bad:
@@ -134,34 +161,47 @@ class SmartG4F:
 
         return time.time() < self.bad[provider.__name__]
 
+    # =================================================
+
     def get_provider(self):
 
         random.shuffle(SAFE_PROVIDERS)
 
-        for provider in SAFE_PROVIDERS:
+        for item in SAFE_PROVIDERS:
+
+            provider = item["provider"]
 
             if self.is_bad(provider):
                 continue
 
-            return provider
+            return item
 
         return None
 
+    # =================================================
+
     def ask(self, prompt):
 
+        last_error = None
+
         for _ in range(MAX_RETRIES):
 
-            provider = self.get_provider()
+            item = self.get_provider()
 
-            if not provider:
+            if not item:
                 break
 
+            provider = item["provider"]
+            model = item["model"]
+
             try:
 
-                logger.info(f"[+] Trying: {provider.__name__}")
+                logger.info(
+                    f"[+] Trying provider={provider.__name__} model={model}"
+                )
 
                 response = client.chat.completions.create(
-                    model=MODEL,
+                    model=model,
                     provider=provider,
                     messages=[
                         {
@@ -172,24 +212,40 @@ class SmartG4F:
                     timeout=TIMEOUT
                 )
 
-                text = response.choices[0].message.content
+                text = None
+
+                try:
+                    text = response.choices[0].message.content
+                except:
+                    text = str(response)
 
-                if text:
+                if text and text.strip():
 
-                    logger.info(f"[+] Success: {provider.__name__}")
+                    logger.info(
+                        f"[+] Success provider={provider.__name__}"
+                    )
 
                     return {
                         "provider": provider.__name__,
+                        "model": model,
                         "response": text
                     }
 
             except Exception as e:
 
-                logger.warning(f"[-] Failed: {provider.__name__} -> {e}")
+                last_error = str(e)
+
+                logger.warning(
+                    f"[-] Failed provider={provider.__name__} error={e}"
+                )
 
                 self.mark_bad(provider)
 
-        raise Exception("All providers failed")
+        raise Exception(last_error or "All providers failed")
+
+# =====================================================
+# INSTANCE
+# =====================================================
 
 smart = SmartG4F()
 
@@ -202,7 +258,7 @@ class ChatRequest(BaseModel):
     prompt: str
 
 # =====================================================
-# ROUTES
+# ROOT
 # =====================================================
 
 @app.get("/")
@@ -211,18 +267,53 @@ async def root():
 
     return {
         "status": "online",
+        "service": "Smart G4F Gateway",
+        "version": "2.0",
         "providers": len(SAFE_PROVIDERS),
-        "model": MODEL
+        "auth": [
+            "Authorization: Bearer",
+            "x-api-key"
+        ]
     }
 
+# =====================================================
+# HEALTH
+# =====================================================
+
 @app.get("/health")
 
 async def health():
 
     return {
-        "ok": True
+        "ok": True,
+        "providers": len(SAFE_PROVIDERS)
     }
 
+# =====================================================
+# MODELS
+# =====================================================
+
+@app.get("/v1/models")
+
+async def models():
+
+    return {
+        "object": "list",
+        "data": [
+            {
+                "id": item["model"],
+                "object": "model",
+                "owned_by": item["provider"].__name__,
+                "created": int(time.time())
+            }
+            for item in SAFE_PROVIDERS
+        ]
+    }
+
+# =====================================================
+# CHAT
+# =====================================================
+
 @app.post("/chat")
 
 async def chat(req: Request, body: ChatRequest):
@@ -236,6 +327,7 @@ async def chat(req: Request, body: ChatRequest):
         return {
             "success": True,
             "provider": result["provider"],
+            "model": result["model"],
             "response": result["response"]
         }
 
@@ -248,6 +340,195 @@ async def chat(req: Request, body: ChatRequest):
             detail=str(e)
         )
 
+# =====================================================
+# OPENAI STYLE ENDPOINT
+# =====================================================
+
+@app.post("/v1/chat/completions")
+
+async def openai_chat(req: Request, body: ChatRequest):
+
+    verify_api_key(req)
+
+    try:
+
+        result = smart.ask(body.prompt)
+
+        return {
+            "id": f"chatcmpl-{random.randint(100000,999999)}",
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": result["model"],
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": result["response"]
+                    },
+                    "finish_reason": "stop"
+                }
+            ]
+        }
+
+    except Exception as e:
+
+        logger.error(traceback.format_exc())
+
+        raise HTTPException(
+            status_code=500,
+            detail=str(e)
+        )
+
+# =====================================================
+# TEST PAGE
+# =====================================================
+
+@app.get("/test")
+
+async def test_page():
+
+    return f"""
+<!DOCTYPE html>
+<html>
+<head>
+<title>Smart G4F Gateway</title>
+<meta charset="utf-8">
+
+<style>
+
+body {{
+    background: #0f172a;
+    color: white;
+    font-family: Arial;
+    max-width: 900px;
+    margin: auto;
+    padding: 20px;
+}}
+
+#chat {{
+    height: 500px;
+    overflow-y: auto;
+    border: 1px solid #334155;
+    padding: 15px;
+    border-radius: 10px;
+    margin-bottom: 10px;
+    background: #111827;
+}}
+
+.user {{
+    background: #2563eb;
+    padding: 10px;
+    border-radius: 10px;
+    margin: 10px;
+    text-align: right;
+}}
+
+.bot {{
+    background: #1e293b;
+    padding: 10px;
+    border-radius: 10px;
+    margin: 10px;
+}}
+
+.input {{
+    display: flex;
+    gap: 10px;
+}}
+
+input {{
+    flex: 1;
+    padding: 12px;
+    border-radius: 10px;
+    border: none;
+}}
+
+button {{
+    padding: 12px 20px;
+    border: none;
+    border-radius: 10px;
+    background: #2563eb;
+    color: white;
+    cursor: pointer;
+}}
+
+</style>
+</head>
+
+<body>
+
+<h2>🤖 Smart G4F Gateway</h2>
+
+<div id="chat"></div>
+
+<div class="input">
+    <input id="message" placeholder="Type message..." />
+    <button onclick="send()">Send</button>
+</div>
+
+<script>
+
+const API_KEY = "{API_KEY}";
+
+async function send() {{
+
+    const input = document.getElementById("message");
+
+    const text = input.value.trim();
+
+    if (!text) return;
+
+    const chat = document.getElementById("chat");
+
+    chat.innerHTML += `
+        <div class="user">${{text}}</div>
+    `;
+
+    input.value = "";
+
+    const bot = document.createElement("div");
+
+    bot.className = "bot";
+
+    bot.innerHTML = "Thinking...";
+
+    chat.appendChild(bot);
+
+    try {{
+
+        const response = await fetch("/chat", {{
+
+            method: "POST",
+
+            headers: {{
+                "Content-Type": "application/json",
+                "x-api-key": API_KEY
+            }},
+
+            body: JSON.stringify({{
+                prompt: text
+            }})
+        }});
+
+        const data = await response.json();
+
+        bot.innerHTML = data.response || data.detail || "Error";
+
+    }} catch(e) {{
+
+        bot.innerHTML = "Error: " + e.message;
+
+    }}
+
+    chat.scrollTop = chat.scrollHeight;
+}}
+
+</script>
+
+</body>
+</html>
+"""
+
 # =====================================================
 # RUN
 # =====================================================
@@ -255,14 +536,18 @@ async def chat(req: Request, body: ChatRequest):
 if __name__ == "__main__":
 
     print("""
-╔══════════════════════════════╗
-║      Smart G4F Gateway      ║
-╠══════════════════════════════╣
-║  API KEY ENABLED            ║
-║  MODEL: gpt-4o-mini         ║
-║  /chat                      ║
-║  /health                    ║
-╚══════════════════════════════╝
+
+╔══════════════════════════════════════╗
+║        SMART G4F GATEWAY            ║
+╠══════════════════════════════════════╣
+║  VERSION : 2.0                      ║
+║  AUTH    : ENABLED                  ║
+║  MODEL   : gpt-4o-mini              ║
+║  TEST UI : /test                    ║
+║  CHAT    : /chat                    ║
+║  OPENAI  : /v1/chat/completions     ║
+╚══════════════════════════════════════╝
+
 """)
 
     uvicorn.run(