Create app.py

app.py

@@ -0,0 +1,491 @@
+import os
+import json
+import time
+import logging
+import asyncio
+import threading
+from typing import Any, Dict, List, Optional
+from collections import OrderedDict
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import StreamingResponse, JSONResponse
+from pydantic import BaseModel
+import g4f
+
+# =====================================================
+# LOGGING
+# =====================================================
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger("g4f-smart-router")
+
+# =====================================================
+# COOKIES
+# =====================================================
+def _load_cookies_raw() -> Dict[str, Any]:
+    raw_env = (os.getenv("COOKIES_JSON") or "").strip()
+    if raw_env:
+        try:
+            return json.loads(raw_env)
+        except Exception as e:
+            logger.warning(f"Failed to load cookies from env: {e}")
+    try:
+        if os.path.exists("cookies.json"):
+            with open("cookies.json", "r", encoding="utf-8") as f:
+                return json.load(f)
+    except Exception as e:
+        logger.warning(f"Failed to load cookies from file: {e}")
+    return {}
+
+def load_cookies() -> str:
+    data = _load_cookies_raw()
+    if not data:
+        return "⚠️ No Cookies"
+    try:
+        from g4f.cookies import set_cookies
+    except Exception:
+        return "⚠️ Cookies Found"
+    for domain, vals in data.items():
+        try:
+            dom = domain if "." in domain else f".{domain}.com"
+            if isinstance(vals, list):
+                vals = {x["name"]: x["value"] for x in vals if isinstance(x, dict)}
+            if isinstance(vals, dict):
+                set_cookies(dom, vals)
+        except Exception as e:
+            logger.warning(f"Cookie error for {domain}: {e}")
+    return "✅ Cookies Loaded"
+
+COOKIE_STATUS = load_cookies()
+
+# =====================================================
+# CACHE
+# =====================================================
+class TTLCache:
+    def __init__(self, max_size: int = 100, ttl_seconds: int = 300):
+        self.cache: OrderedDict = OrderedDict()
+        self.max_size = max_size
+        self.ttl = ttl_seconds
+        self._lock = threading.Lock()
+        self._last_cleanup = time.time()
+        self._cleanup_interval = 60
+
+    def _clean_expired(self):
+        now = time.time()
+        if now - self._last_cleanup < self._cleanup_interval:
+            return
+        self._last_cleanup = now
+        expired = [k for k, (_, ts) in self.cache.items() if now - ts > self.ttl]
+        for k in expired:
+            del self.cache[k]
+
+    def get(self, key: str) -> Optional[str]:
+        with self._lock:
+            if key in self.cache:
+                value, _ = self.cache[key]
+                self.cache.move_to_end(key)
+                return value
+            return None
+
+    def set(self, key: str, value: str):
+        with self._lock:
+            self._clean_expired()
+            if len(self.cache) >= self.max_size:
+                self.cache.popitem(last=False)
+            self.cache[key] = (value, time.time())
+
+CACHE = TTLCache(max_size=100, ttl_seconds=300)
+
+# =====================================================
+# PROVIDERS
+# =====================================================
+def get_provider(name: str):
+    try:
+        return getattr(g4f.Provider, name)
+    except:
+        return None
+
+REAL_PROVIDERS = {
+    "Perplexity": get_provider("Perplexity") or get_provider("PerplexityAi"),
+    "Copilot": get_provider("Copilot"),
+    "Qwen": get_provider("Qwen"),
+    "Blackbox": get_provider("Blackbox"),
+    "DeepSeek": get_provider("DeepSeek"),
+    "Bing": get_provider("Bing"),
+    "You": get_provider("You"),
+}
+REAL_PROVIDERS = {k: v for k, v in REAL_PROVIDERS.items() if v}
+
+# =====================================================
+# MODEL FALLBACK
+# =====================================================
+PROVIDER_MODELS_FALLBACK = {
+    "Perplexity": ["sonar", "sonar-pro", "gpt-4o", "llama-3"],
+    "Copilot": ["gpt-4o", "gpt-4", "turbo"],
+    "Qwen": ["qwen-max", "qwen-plus", "qwen-turbo", "qwen"],
+    "Blackbox": ["gpt-4o", "claude-3", "gemini-pro", "llama-3"],
+    "DeepSeek": ["deepseek-chat", "deepseek-coder"],
+    "Bing": ["gpt-4o", "gpt-4"],
+    "You": ["gpt-4o", "claude", "llama-3"],
+}
+
+# =====================================================
+# MODEL DISCOVERY
+# =====================================================
+_PROVIDER_MODEL_CACHE = {}
+
+def discover_provider_models(provider_obj: Any, provider_name: str) -> List[str]:
+    candidates = []
+    for attr in ("models", "model", "default_model", "available_models", "supported_models"):
+        try:
+            if hasattr(provider_obj, attr):
+                val = getattr(provider_obj, attr)
+                if isinstance(val, dict):
+                    candidates.extend(str(k) for k in val.keys())
+                elif isinstance(val, (list, tuple, set)):
+                    candidates.extend(str(i) for i in val)
+                elif val:
+                    candidates.append(str(val))
+        except:
+            pass
+    if not candidates:
+        candidates = PROVIDER_MODELS_FALLBACK.get(provider_name, ["gpt-4o"])
+    seen = set()
+    return [m for m in candidates if not (m in seen or seen.add(m))]
+
+# =====================================================
+# STREAM CLEANER
+# =====================================================
+def clean_stream(chunk):
+    try:
+        if isinstance(chunk, dict):
+            if 'choices' in chunk and chunk['choices']:
+                delta = chunk['choices'][0].get('delta', {})
+                if 'content' in delta:
+                    return delta['content']
+                if 'text' in delta:
+                    return delta['text']
+            return chunk.get('content') or chunk.get('text') or ""
+
+        if isinstance(chunk, str):
+            if chunk and chunk[0] == '{' and chunk[-1] == '}':
+                try:
+                    data = json.loads(chunk)
+                    if 'choices' in data and data['choices']:
+                        delta = data['choices'][0].get('delta', {})
+                        if 'content' in delta:
+                            return delta['content']
+                    return data.get('content') or data.get('text') or ""
+                except:
+                    pass
+            if '\\' in chunk:
+                chunk = chunk.replace('\\n', '\n')
+                if '\\r' in chunk:
+                    chunk = chunk.replace('\\r', '\r')
+                if '\\t' in chunk:
+                    chunk = chunk.replace('\\t', '    ')
+            return chunk
+        return str(chunk)
+    except Exception:
+        return ""
+
+# =====================================================
+# CHAT LOGIC
+# =====================================================
+def ask(message: str, history, provider_name: str, model_name: str, stop_flag=None):
+    message = (message or "").strip()
+    if not message:
+        yield ""
+        return
+
+    key = f"{provider_name}|{model_name}|{message}"
+    cached = CACHE.get(key)
+    if cached:
+        yield cached
+        return
+
+    msgs = []
+    try:
+        if history:
+            if history and isinstance(history[0], dict):
+                for item in history[-40:]:
+                    if role := item.get("role"):
+                        if content := item.get("content"):
+                            msgs.append({"role": str(role), "content": str(content)})
+            else:
+                for item in history[-20:]:
+                    if isinstance(item, (list, tuple)) and len(item) == 2:
+                        if u := item[0]:
+                            msgs.append({"role": "user", "content": str(u)})
+                        if a := item[1]:
+                            msgs.append({"role": "assistant", "content": str(a)})
+    except Exception as e:
+        logger.warning(f"History error: {e}")
+
+    msgs.append({"role": "user", "content": message})
+
+    fallback_providers = [
+        provider_name, "Perplexity", "Copilot", "Blackbox", "DeepSeek", "Bing", "You", "Qwen"
+    ]
+    used = []
+
+    for pname in fallback_providers:
+        if pname in used:
+            continue
+        used.append(pname)
+        pobj = REAL_PROVIDERS.get(pname)
+        if not pobj:
+            continue
+
+        if pname not in _PROVIDER_MODEL_CACHE:
+            _PROVIDER_MODEL_CACHE[pname] = discover_provider_models(pobj, pname)
+
+        model_candidates = [model_name] + [x for x in _PROVIDER_MODEL_CACHE[pname] if x != model_name]
+
+        for m in model_candidates[:12]:
+            try:
+                stream = g4f.ChatCompletion.create(
+                    model=m,
+                    provider=pobj,
+                    messages=msgs,
+                    stream=True,
+                    timeout=30
+                )
+
+                buffer = []
+
+                for chunk in stream:
+                    if stop_flag and stop_flag.is_set():
+                        return
+                    c = clean_stream(chunk)
+                    if not c:
+                        continue
+                    buffer.append(c)
+                    yield c
+
+                full = "".join(buffer)
+                if full.strip():
+                    CACHE.set(key, full)
+                    return
+
+            except Exception as e:
+                logger.warning(f"Provider {pname} model {m} failed: {e}")
+                continue
+
+    yield "❌ Failed with all providers."
+
+# =====================================================
+# FASTAPI
+# =====================================================
+app = FastAPI(title="G4F Smart Router", description="Claude-compatible AI Gateway")
+
+API_KEY = os.getenv("API_KEY", "mysecretkey123")
+
+class ChatRequest(BaseModel):
+    message: str
+    provider: str = "Perplexity"
+    model: str = "sonar"
+    history: List[Any] = []
+
+# =====================================================
+# Claude Desktop / Claude Code Compatible Endpoints
+# =====================================================
+
+def verify_api_key(request: Request):
+    auth = request.headers.get("Authorization", "").strip()
+    x_key = request.headers.get("X-API-Key", "").strip()
+    x_api_key = request.headers.get("x-api-key", "").strip()
+
+    if auth.startswith("Bearer "):
+        key = auth[7:].strip()
+        if key and key == API_KEY:
+            return True
+    if x_key and x_key == API_KEY:
+        return True
+    if x_api_key and x_api_key == API_KEY:
+        return True
+
+    raise HTTPException(status_code=401, detail="Invalid API key. Use 'Authorization: Bearer KEY' or 'X-API-Key: KEY'")
+
+@app.post("/v1/messages")
+async def v1_messages(request: Request):
+    """Anthropic API compatible endpoint for Claude Desktop / Claude Code"""
+    verify_api_key(request)
+    
+    body = await request.json()
+    
+    # استخراج الرسالة من تنسيق Anthropic
+    messages = body.get("messages", [])
+    if not messages:
+        raise HTTPException(status_code=400, detail="No messages provided")
+    
+    last_message = messages[-1]
+    user_message = last_message.get("content", "")
+    
+    # استخراج النموذج
+    model = body.get("model", "sonar")
+    
+    # استخراج النظام (system prompt) إن وجد
+    system_prompt = body.get("system", "")
+    
+    # بناء التاريخ من الرسائل السابقة
+    history = []
+    for msg in messages[:-1]:
+        role = msg.get("role", "user")
+        content = msg.get("content", "")
+        history.append({"role": role, "content": content})
+    
+    # إضافة system prompt إذا موجود
+    full_message = user_message
+    if system_prompt:
+        full_message = f"[System: {system_prompt}]\n\n{user_message}"
+    
+    # الحصول على الرد
+    full_response = ""
+    for chunk in ask(full_message, history, "Perplexity", model):
+        full_response = chunk
+    
+    # إرجاع الرد بتنسيق Anthropic API
+    return {
+        "id": f"msg_{int(time.time())}_{os.urandom(4).hex()}",
+        "type": "message",
+        "role": "assistant",
+        "content": [{"type": "text", "text": full_response}],
+        "model": model,
+        "stop_reason": "end_turn",
+        "stop_sequence": None,
+        "usage": {
+            "input_tokens": len(user_message) // 4,
+            "output_tokens": len(full_response) // 4
+        }
+    }
+
+@app.post("/v1/messages/stream")
+async def v1_messages_stream(request: Request):
+    """Anthropic API compatible streaming endpoint"""
+    verify_api_key(request)
+    
+    body = await request.json()
+    messages = body.get("messages", [])
+    if not messages:
+        raise HTTPException(status_code=400, detail="No messages provided")
+    
+    last_message = messages[-1]
+    user_message = last_message.get("content", "")
+    model = body.get("model", "sonar")
+    
+    async def generate_stream():
+        message_id = f"msg_{int(time.time())}_{os.urandom(4).hex()}"
+        
+        # رسالة البدء
+        yield f"event: message_start\ndata: {{\"message\": {{\"id\": \"{message_id}\", \"type\": \"message\", \"role\": \"assistant\", \"content\": [], \"model\": \"{model}\", \"stop_reason\": null, \"stop_sequence\": null, \"usage\": {{\"input_tokens\": 0, \"output_tokens\": 0}}}}}}\n\n"
+        
+        # رسالة التدفق
+        for chunk in ask(user_message, [], "Perplexity", model):
+            yield f"event: content_block_delta\ndata: {{\"type\": \"content_block_delta\", \"index\": 0, \"delta\": {{\"type\": \"text_delta\", \"text\": {json.dumps(chunk, ensure_ascii=False)}}}}}\n\n"
+        
+        # رسالة النهاية
+        yield f"event: message_delta\ndata: {{\"type\": \"message_delta\", \"delta\": {{\"stop_reason\": \"end_turn\", \"stop_sequence\": null}}, \"usage\": {{\"output_tokens\": 100}}}}\n\n"
+        yield f"event: message_stop\ndata: {{}}\n\n"
+    
+    return StreamingResponse(
+        generate_stream(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "Content-Type": "text/event-stream"
+        }
+    )
+
+@app.get("/v1/models")
+async def v1_models(request: Request):
+    """Anthropic API compatible models endpoint"""
+    verify_api_key(request)
+    
+    models = []
+    for pname, pobj in REAL_PROVIDERS.items():
+        if pname not in _PROVIDER_MODEL_CACHE:
+            _PROVIDER_MODEL_CACHE[pname] = discover_provider_models(pobj, pname)
+        for model in _PROVIDER_MODEL_CACHE[pname]:
+            models.append({
+                "id": model,
+                "type": "model",
+                "display_name": f"{pname} - {model}",
+                "created_at": "2024-01-01T00:00:00Z"
+            })
+    
+    return {"data": models}
+
+# =====================================================
+# ORIGINAL ENDPOINTS (للتوافق مع الواجهة القديمة)
+# =====================================================
+
+@app.get("/")
+async def root():
+    return {
+        "message": "G4F Smart Router is running (Claude-compatible)",
+        "endpoints": {
+            "GET /": "هذه الصفحة",
+            "GET /health": "التحقق من صحة الخادم",
+            "GET /v1/models": "قائمة النماذج (Claude-compatible)",
+            "POST /v1/messages": "إرسال رسالة (Claude-compatible)",
+            "POST /v1/messages/stream": "إرسال رسالة متدفق (Claude-compatible)",
+            "GET /providers": "قائمة المزودين (يتطلب مفتاح)",
+            "POST /chat": "إرسال رسالة (legacy)",
+            "POST /chat/stream": "إرسال رسالة متدفق (legacy)"
+        },
+        "authentication": "Bearer YOUR_API_KEY or X-API-Key: YOUR_API_KEY",
+        "cookies": COOKIE_STATUS,
+        "status": "✅ Server is working"
+    }
+
+@app.get("/health")
+async def health():
+    return {"status": "ok", "cookies": COOKIE_STATUS, "providers": list(REAL_PROVIDERS.keys())}
+
+@app.post("/chat")
+async def chat(request: Request, chat_req: ChatRequest):
+    verify_api_key(request)
+
+    result = ""
+    for chunk in ask(chat_req.message, chat_req.history, chat_req.provider, chat_req.model):
+        result = chunk
+
+    return JSONResponse({"response": result})
+
+@app.post("/chat/stream")
+async def chat_stream(request: Request, chat_req: ChatRequest):
+    verify_api_key(request)
+
+    async def generate():
+        for chunk in ask(chat_req.message, chat_req.history, chat_req.provider, chat_req.model):
+            yield f"data: {json.dumps({'delta': chunk}, ensure_ascii=False)}\n\n"
+        yield "data: [DONE]\n\n"
+
+    return StreamingResponse(generate(), media_type="text/event-stream")
+
+@app.get("/providers")
+async def get_providers(request: Request):
+    verify_api_key(request)
+
+    providers_info = {}
+    for pname, pobj in REAL_PROVIDERS.items():
+        if pname not in _PROVIDER_MODEL_CACHE:
+            _PROVIDER_MODEL_CACHE[pname] = discover_provider_models(pobj, pname)
+        providers_info[pname] = _PROVIDER_MODEL_CACHE[pname]
+
+    return JSONResponse({"providers": providers_info})
+
+# =====================================================
+# RUN
+# =====================================================
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        "app:app",
+        host="0.0.0.0",
+        port=int(os.getenv("PORT", 7860)),
+        reload=False
+    )