Update app.py

app.py

@@ -1,1119 +1,276 @@
-"""
-╔══════════════════════════════════════════════════════════════════╗
-║                    SmartG4F API - محسّن بالكامل                  ║
-║                         بدون أي قيود                            ║
-╚══════════════════════════════════════════════════════════════════╝
-"""
-
-# ============================================================
-#Imports
-# ============================================================
-import os
-import sys
 import time
 import random
-import asyncio
 import traceback
-import json
 import uuid
-import logging
-import threading
-import hashlib
-from datetime import datetime, timedelta
-from collections import deque
-from typing import Optional, List, Dict, Any, Union
-from contextlib import asynccontextmanager
-from functools import wraps
-import re
-
-# FastAPI & Dependencies
-from fastapi import FastAPI, HTTPException, Depends, Header, Request, Response
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import StreamingResponse, JSONResponse
-from fastapi.staticfiles import StaticFiles
-from pydantic import BaseModel, Field, validator
+
+from fastapi import FastAPI, Header, HTTPException
+from pydantic import BaseModel
 import uvicorn
 
-# g4f Dependencies
 from g4f.client import Client
 from g4f.Provider import __providers__
 
-# ============================================================
-# إعدادات الـ Logging المحسّن
-# ============================================================
-class ColoredFormatter(logging.Formatter):
-    """تنسيق Logs ملون للتمييز"""
-    COLORS = {
-        'DEBUG': '\033[36m',     # Cyan
-        'INFO': '\033[32m',      # Green
-        'WARNING': '\033[33m',   # Yellow
-        'ERROR': '\033[31m',     # Red
-        'CRITICAL': '\033[35m',  # Magenta
-        'RESET': '\033[0m'
-    }
-    
-    def format(self, record):
-        color = self.COLORS.get(record.levelname, self.COLORS['RESET'])
-        record.levelname = f"{color}{record.levelname}{self.COLORS['RESET']}"
-        return super().format(record)
-
-# إعداد الـ Logger
-logger = logging.getLogger("SmartG4F")
-logger.setLevel(logging.DEBUG)
-
-# Console Handler
-console_handler = logging.StreamHandler()
-console_handler.setLevel(logging.DEBUG)
-console_handler.setFormatter(ColoredFormatter(
-    '%(asctime)s │ %(levelname)s │ %(message)s',
-    datefmt='%H:%M:%S'
-))
-logger.addHandler(console_handler)
-
-# ============================================================
-# إعداد نظام البروكسي (Proxies) - بدون قيود
-# ============================================================
-PROXIES_POOL: List[str] = []
-
-def load_proxies():
-    """تحميل البروكسيات من مصادر متعددة"""
-    global PROXIES_POOL
-    
-    # 1. من Environment Variable
-    env_proxies = os.environ.get("PROXIES_LIST", "")
-    if env_proxies:
-        PROXIES_POOL.extend([p.strip() for p in env_proxies.split(",") if p.strip()])
-    
-    # 2. من ملف proxies.txt
-    if os.path.exists("proxies.txt"):
-        with open("proxies.txt", "r") as f:
-            PROXIES_POOL.extend([line.strip() for line in f if line.strip()])
-    
-    # 3. البروكسي الفردي
-    single_proxy = os.environ.get("STRONG_PROXY_URL") or os.environ.get("HTTP_PROXY")
-    if single_proxy and single_proxy not in PROXIES_POOL:
-        PROXIES_POOL.append(single_proxy)
-    
-    # إزالة المكررات
-    PROXIES_POOL = list(dict.fromkeys(PROXIES_POOL))
-    
-    logger.info(f"📡 تم تحميل {len(PROXIES_POOL)} بروكسي")
-
-def get_random_proxy() -> Optional[str]:
-    """جلب بروكسي عشوائي"""
-    if not PROXIES_POOL:
-        # محاولة تحميل البروكسيات
-        load_proxies()
-    
-    if PROXIES_POOL:
-        proxy = random.choice(PROXIES_POOL)
-        # التحقق من صحة البروكسي
-        if _validate_proxy(proxy):
-            return proxy
-    
-    return None
-
-def _validate_proxy(proxy: str) -> bool:
-    """التحقق من صحة صيغة البروكسي"""
-    if not proxy:
-        return False
-    # صيغ مقبولة:
-    # http://host:port
-    # http://user:pass@host:port
-    # socks5://host:port
-    patterns = [
-        r'^https?://[\w\-\.]+:\d+$',
-        r'^https?://[\w\-\.]+:\d+@[\w\-\.]+:\d+$',
-        r'^socks5?://[\w\-\.]+:\d+$',
-    ]
-    return any(re.match(p, proxy) for p in patterns)
-
-# ============================================================
-# تصفية وتجهيز المزودات (Safe Providers)
-# ============================================================
-MODEL = os.environ.get("DEFAULT_MODEL", "gpt-4o-mini")
-MAX_RETRIES = int(os.environ.get("MAX_RETRIES", "15"))
-TIMEOUT = int(os.environ.get("TIMEOUT", "120"))
-MAX_PROVIDERS_IN_MEMORY = 100
+MODEL = "gpt-4o-mini"
+
+MAX_RETRIES = 10
+TIMEOUT = 60
+
+# ضع المفتاح هنا
+OPENAI_API_KEY = "sk-your-key"
 
 SAFE_PROVIDERS = []
+
 for provider in __providers__:
+
     try:
+
         name = provider.__name__.lower()
-        
-        # تصفية المزودات غير العاملة
+
         if not getattr(provider, "working", False):
             continue
-        
-        # تخطي المزودات التي تحتاج تسجيل
+
         if getattr(provider, "needs_auth", False):
             continue
-        
-        # تخطي المزودات التي تحتاج nodriver
+
         if getattr(provider, "use_nodriver", False):
             continue
-        
-        # منع المزودات المحظورة
-        blocked = ["openai", "qwen", "copilot", "gemini", "claude"]
+
+        blocked = [
+            "openai",
+            "qwen",
+            "copilot",
+            "gemini",
+            "claude",
+        ]
+
         if any(x in name for x in blocked):
             continue
-        
+
         SAFE_PROVIDERS.append(provider)
+
     except:
         pass
 
 random.shuffle(SAFE_PROVIDERS)
-logger.info(f"✅ SAFE PROVIDERS: {len(SAFE_PROVIDERS)}")
-
-# ============================================================
-# إنشاء ملف config.json تلقائياً لـ Context7 MCP
-# ============================================================
-CONFIG_PATH = "config.json"
-if not os.path.exists(CONFIG_PATH):
-    context7_key = os.environ.get("CONTEXT7_API_KEY", "")
-    if context7_key:
-        config_data = {
-            "mcpServers": {
-                "context7": {
-                    "url": "https://mcp.context7.com/mcp",
-                    "headers": {
-                        "Authorization": f"Bearer {context7_key}"
-                    }
-                }
-            }
-        }
-        with open(CONFIG_PATH, "w", encoding="utf-8") as f:
-            json.dump(config_data, f, indent=2, ensure_ascii=False)
-        logger.info("[+] config.json auto-generated for Context7 MCP")
-    else:
-        logger.warning("[!] CONTEXT7_API_KEY not set; skipping config.json creation")
-
-# ============================================================
-# نظام إدارة الـ Client المحسّن
-# ============================================================
-class ClientManager:
-    """مدير الـ Clients للاتصال بـ g4f"""
-    _instances: Dict[str, 'Client'] = {}
-    _lock = threading.Lock()
-    _max_instances = 50
-    
-    @classmethod
-    def get_client(cls, proxy: Optional[str] = None) -> 'Client':
-        """الحصول على Client (مع أو بدون بروكسي)"""
-        key = proxy or "default"
-        
-        with cls._lock:
-            if key not in cls._instances:
-                if len(cls._instances) >= cls._max_instances:
-                    # إزالة أقدم client
-                    oldest_key = next(iter(cls._instances))
-                    del cls._instances[oldest_key]
-                
-                cls._instances[key] = Client(proxy=proxy)
-                logger.debug(f"🆕 New client created: {key[:20]}...")
-            
-            return cls._instances[key]
-
-# ============================================================
-# نظام SmartG4F المحسّن بالكامل
-# ============================================================
+
+print(f"[+] SAFE PROVIDERS: {len(SAFE_PROVIDERS)}")
+
+client = Client()
+
+
 class SmartG4F:
-    """
-    نظام ذكي لإدارة Providers
-    - تتبع Providers الناجحة والفاشلة
-    - إدارة ذاكرة محسّنة
-    - إحصائيات مفصلة
-    - Thread-Safe
-    """
-    
-    def __init__(self, max_good_providers: int = MAX_PROVIDERS_IN_MEMORY):
-        # Good Providers - محدود بحجم ثابت
-        self.good = deque(maxlen=max_good_providers)
-        
-        # Bad Providers - مع وقت انتهاء
-        self.bad: Dict[str, float] = {}
-        
-        # قفل للأمان في تعدد الخيوط
-        self.lock = threading.Lock()
-        
-        # إحصائيات شاملة
-        self.stats = {
-            "total_requests": 0,
-            "successful_requests": 0,
-            "failed_requests": 0,
-            "total_tokens_used": 0,
-            "avg_response_time": 0,
-            "start_time": time.time()
-        }
-        
-        # سجل الأخطاء الأخير
-        self.error_log: deque = deque(maxlen=100)
-        
-        # Provider Stats
-        self.provider_stats: Dict[str, Dict] = {}
-    
-    def mark_good(self, provider) -> None:
-        """وضع Provider في قائمة الناجحين"""
-        with self.lock:
-            provider_name = provider.__name__
-            if provider not in self.good:
-                self.good.append(provider)
-            
-            # تحديث الإحصائيات
-            if provider_name not in self.provider_stats:
-                self.provider_stats[provider_name] = {
-                    "success": 0, "failed": 0, "avg_time": 0
-                }
-            self.provider_stats[provider_name]["success"] += 1
-    
-    def mark_bad(self, provider, cooldown: int = 300) -> None:
-        """وضع Provider في قائمة الفاشلين"""
-        with self.lock:
-            provider_name = provider.__name__
-            self.bad[provider_name] = time.time() + cooldown
-            
-            # تحديث الإحصائيات
-            if provider_name not in self.provider_stats:
-                self.provider_stats[provider_name] = {
-                    "success": 0, "failed": 0, "avg_time": 0
-                }
-            self.provider_stats[provider_name]["failed"] += 1
-            
-            logger.warning(f"⚠️ Provider marked bad: {provider_name} (cooldown: {cooldown}s)")
-    
-    def is_bad(self, provider) -> bool:
-        """فحص إذا كان Provider في قائمة الحظر"""
-        with self.lock:
-            provider_name = provider.__name__
-            expire = self.bad.get(provider_name)
-            
-            if not expire:
-                return False
-            
-            if time.time() > expire:
-                del self.bad[provider_name]
-                logger.info(f"✅ Provider recovered: {provider_name}")
-                return False
-            
-            return True
-    
-    def provider_pool(self) -> List:
-        """إنشاء pool من Providers المتاحة"""
-        with self.lock:
-            providers = list(self.good)
-            
-            for p in SAFE_PROVIDERS:
-                if p not in providers and not self.is_bad(p):
-                    providers.append(p)
-            
-            random.shuffle(providers)
-            return providers
-    
-    def get_stats(self) -> Dict[str, Any]:
-        """الحصول على الإحصائيات"""
-        with self.lock:
-            uptime = time.time() - self.stats["start_time"]
-            success_rate = (
-                self.stats["successful_requests"] / self.stats["total_requests"] * 100
-                if self.stats["total_requests"] > 0 else 0
-            )
-            
-            return {
-                **self.stats,
-                "uptime_seconds": uptime,
-                "uptime_human": str(timedelta(seconds=int(uptime))),
-                "success_rate": round(success_rate, 2),
-                "good_providers": len(self.good),
-                "bad_providers": len(self.bad),
-                "available_providers": len(self.provider_pool()),
-                "provider_stats": dict(self.provider_stats),
-                "recent_errors": list(self.error_log)
-            }
-    
-    def ask(
-        self, 
-        prompt: str, 
-        temperature: float = 0.7,
-        max_tokens: Optional[int] = None,
-        stream: bool = False
-    ) -> Dict[str, Any]:
-        """إرسال طلب ونيل الرد"""
-        request_id = str(uuid.uuid4())[:8]
+
+    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):
+
+        expire = self.bad.get(provider.__name__)
+
+        if not expire:
+            return False
+
+        if time.time() > expire:
+            del self.bad[provider.__name__]
+            return False
+
+        return True
+
+    def provider_pool(self):
+
+        providers = []
+
+        providers.extend(self.good)
+
+        for p in SAFE_PROVIDERS:
+
+            if p not in providers and not self.is_bad(p):
+                providers.append(p)
+
+        random.shuffle(providers)
+
+        return providers
+
+    def ask(self, messages):
+
         errors = []
-        start_time = time.time()
-        
-        with self.lock:
-            self.stats["total_requests"] += 1
-        
-        logger.info(f"🎯 [{request_id}] New request started")
-        logger.debug(f"📝 Prompt length: {len(prompt)} chars")
-        
+
         for attempt in range(MAX_RETRIES):
+
             pool = self.provider_pool()
-            
+
             if not pool:
-                error_msg = "❌ No providers available"
-                logger.error(f"🚫 [{request_id}] {error_msg}")
-                with self.lock:
-                    self.stats["failed_requests"] += 1
-                    self.error_log.append({
-                        "time": datetime.now().isoformat(),
-                        "error": error_msg,
-                        "request_id": request_id
-                    })
+
                 return {
-                    "success": False, 
-                    "error": error_msg,
-                    "request_id": request_id
+                    "success": False,
+                    "error": "No providers available"
                 }
-            
+
             provider = random.choice(pool)
-            current_proxy = get_random_proxy()
-            
-            logger.info(
-                f"🔄 [{request_id}] Attempt {attempt + 1}/{MAX_RETRIES} | "
-                f"Provider: {provider.__name__} | "
-                f"Proxy: {'Yes ✅' if current_proxy else 'No ❌'}"
-            )
-            
+
+            print(f"[TRY {attempt+1}] {provider.__name__}")
+
             try:
-                # الحصول على Client
-                client = ClientManager.get_client(proxy=current_proxy)
-                
-                # تجهيز الرسائل
-                messages = [{"role": "user", "content": prompt}]
-                
-                # إرسال الطلب
-                request_start = time.time()
-                
+
                 response = client.chat.completions.create(
                     model=MODEL,
                     provider=provider,
                     messages=messages,
-                    temperature=temperature,
-                    max_tokens=max_tokens,
-                    timeout=TIMEOUT
+                    timeout=TIMEOUT,
                 )
-                
-                request_time = time.time() - request_start
-                
-                # استخراج النص
+
                 text = response.choices[0].message.content
-                
+
                 if not text:
-                    raise Exception("Empty response received")
-                
-                # تحديث الإحصائيات
-                with self.lock:
-                    self.stats["successful_requests"] += 1
-                    self.stats["total_tokens_used"] += len(text.split())
-                    
-                    # حساب متوسط وقت الاستجابة
-                    old_avg = self.stats["avg_response_time"]
-                    total = self.stats["successful_requests"]
-                    self.stats["avg_response_time"] = (
-                        (old_avg * (total - 1) + request_time) / total
-                    )
-                
-                # وضع Provider في قائمة الناجحين
-                self.mark_good(provider)
-                
-                response_data = {
+                    raise Exception("Empty response")
+
+                if provider not in self.good:
+                    self.good.append(provider)
+
+                return {
                     "success": True,
-                    "request_id": request_id,
                     "provider": provider.__name__,
-                    "response": text,
-                    "response_time": round(request_time, 3),
-                    "tokens_used": len(text.split()),
-                    "proxy_used": bool(current_proxy)
+                    "response": text
                 }
-                
-                logger.info(
-                    f"✅ [{request_id}] Success! | "
-                    f"Provider: {provider.__name__} | "
-                    f"Time: {request_time:.2f}s | "
-                    f"Length: {len(text)} chars"
-                )
-                
-                return response_data
-                
+
             except Exception as e:
-                error_str = str(e)
-                error_lower = error_str.lower()
-                request_time = time.time() - start_time
-                
-                # تسجيل الخطأ
-                error_entry = {
-                    "time": datetime.now().isoformat(),
+
+                err = str(e).lower()
+
+                traceback.print_exc()
+
+                errors.append({
                     "provider": provider.__name__,
-                    "error": error_str,
-                    "attempt": attempt + 1,
-                    "request_id": request_id
-                }
-                
-                with self.lock:
-                    self.error_log.append(error_entry)
-                
-                logger.error(
-                    f"❌ [{request_id}] Error: {error_str[:100]} | "
-                    f"Provider: {provider.__name__}"
-                )
-                
-                if logger.level == logging.DEBUG:
-                    traceback.print_exc()
-                
-                errors.append(error_entry)
-                
-                # تحديد وقت الانتظار حسب نوع الخطأ
-                if "429" in error_lower or "rate limit" in error_lower:
-                    cooldown = random.randint(600, 1200)
-                    sleep_time = random.randint(15, 30)
-                    logger.warning(f"⏳ Rate limited - sleeping {sleep_time}s")
-                    time.sleep(sleep_time)
-                    
-                elif "cloudflare" in error_lower or "cf" in error_lower:
-                    cooldown = random.randint(1200, 2400)
-                    sleep_time = 30
-                    logger.warning(f"🛡️ Cloudflare blocked - sleeping {sleep_time}s")
-                    time.sleep(sleep_time)
-                    
-                elif "timeout" in error_lower:
-                    cooldown = random.randint(300, 600)
-                    sleep_time = random.randint(5, 15)
-                    logger.warning(f"⏰ Timeout - sleeping {sleep_time}s")
-                    time.sleep(sleep_time)
-                    
-                elif "connection" in error_lower:
-                    cooldown = random.randint(60, 180)
-                    sleep_time = random.randint(3, 10)
-                    logger.warning(f"🔗 Connection error - sleeping {sleep_time}s")
-                    time.sleep(sleep_time)
-                    
+                    "error": str(e)
+                })
+
+                if "429" in err:
+
+                    self.mark_bad(provider, 600)
+                    time.sleep(random.randint(10, 20))
+
+                elif "cloudflare" in err:
+
+                    self.mark_bad(provider, 1200)
+                    time.sleep(20)
+
+                elif "timeout" in err:
+
+                    self.mark_bad(provider, 300)
+
                 else:
-                    cooldown = random.randint(180, 300)
-                    sleep_time = random.randint(2, 5)
-                    time.sleep(sleep_time)
-                
-                self.mark_bad(provider, cooldown)
+
+                    self.mark_bad(provider, 180)
+
                 continue
-        
-        # فشل جميع المحاولات
-        with self.lock:
-            self.stats["failed_requests"] += 1
-        
-        logger.error(f"🚫 [{request_id}] All {MAX_RETRIES} attempts failed")
-        
+
         return {
             "success": False,
-            "request_id": request_id,
-            "error": f"Failed after {MAX_RETRIES} attempts",
-            "errors": errors,
-            "total_time": round(time.time() - start_time, 3)
+            "errors": errors
         }
 
-# ============================================================
-# نماذج Pydantic للتحقق من البيانات
-# ============================================================
+
+app = FastAPI()
+
+ai = SmartG4F()
+
+
+# =========================
+# OpenAI Compatible Models
+# =========================
+
 class Message(BaseModel):
-    """نموذج رسالة واحدة"""
-    role: str = Field(..., pattern="^(system|user|assistant)$")
+    role: str
     content: str
-    
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "role": "user",
-                "content": "مرحباً، كيف حالك؟"
-            }
-        }
 
-class ChatCompletionRequest(BaseModel):
-    """نموذج طلب الإكمال - متوافق مع OpenAI"""
-    model: str = Field(default=MODEL, description="نموذج الذكاء الاصطناعي")
-    messages: List[Message] = Field(
-        ..., 
-        description="قائمة الرسائل",
-        min_length=1
-    )
-    temperature: float = Field(
-        default=0.7, 
-        ge=0.0, 
-        le=2.0,
-        description="درجة الإبداع (0-2)"
-    )
-    max_tokens: Optional[int] = Field(
-        default=4096,
-        ge=1,
-        le=32000,
-        description="الحد الأقصى للرموز"
-    )
-    stream: bool = Field(
-        default=False,
-        description="تفعيل البث المباشر"
-    )
-    top_p: Optional[float] = Field(
-        default=1.0,
-        ge=0.0,
-        le=1.0,
-        description="نسبة أخذ العينات"
-    )
-    frequency_penalty: Optional[float] = Field(
-        default=0.0,
-        ge=-2.0,
-        le=2.0
-    )
-    presence_penalty: Optional[float] = Field(
-        default=0.0,
-        ge=-2.0,
-        le=2.0
-    )
-    stop: Optional[List[str]] = Field(
-        default=None,
-        description="كلمات الإيقاف"
-    )
-    
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "model": "gpt-4o-mini",
-                "messages": [
-                    {"role": "user", "content": "اكتب قصة قصيرة"}
-                ],
-                "temperature": 0.7,
-                "max_tokens": 1000,
-                "stream": False
-            }
-        }
 
-class CompletionRequest(BaseModel):
-    """نموذج طلب الإكمال للنصوص"""
-    model: str = Field(default=MODEL)
-    prompt: str = Field(..., min_length=1)
-    temperature: float = Field(default=0.7, ge=0.0, le=2.0)
-    max_tokens: Optional[int] = Field(default=4096, ge=1)
-    stream: bool = Field(default=False)
-    n: int = Field(default=1, ge=1, le=10)
-
-class EmbeddingRequest(BaseModel):
-    """نموذج طلب التضميد"""
-    model: str = Field(default="text-embedding-3-small")
-    input: Union[str, List[str]]
-
-# ============================================================
-# نظام الحماية - بدون Rate Limiting
-# ============================================================
-def verify_api_key(authorization: Optional[str] = Header(None)) -> bool:
-    """التحقق من مفتاح API"""
-    expected_key = os.environ.get("MY_PROJECT_API_KEY")
-    
-    if not expected_key:
-        # إذا لم يتم تعيين مفتاح، نسمح بالوصول مع تح��ير
-        logger.warning("⚠️ WARNING: No API key configured - running in open mode")
-        return True
-    
-    if not authorization:
-        raise HTTPException(
-            status_code=403, 
-            detail="❌ Missing Authorization header"
-        )
-    
-    if not authorization.startswith("Bearer "):
-        raise HTTPException(
-            status_code=403, 
-            detail="❌ Invalid authorization header format. Use: Bearer <token>"
-        )
-    
-    token = authorization.split(" ", 1)[1]
-    
-    if token != expected_key:
-        raise HTTPException(
-            status_code=403, 
-            detail="❌ Invalid API key"
-        )
-    
-    return True
-
-def get_client_ip(request: Request) -> str:
-    """الحصول على IP العميل"""
-    forwarded = request.headers.get("X-Forwarded-For")
-    if forwarded:
-        return forwarded.split(",")[0].strip()
-    return request.client.host if request.client else "unknown"
-
-# ============================================================
-# إعداد التطبيق
-# ============================================================
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """إدارة دورة حياة التطبيق"""
-    # Startup
-    logger.info("=" * 60)
-    logger.info("🚀 SmartG4F API Starting...")
-    logger.info("=" * 60)
-    
-    # تحميل البروكسيات
-    load_proxies()
-    
-    # إنشاء مجلدات إذا لم تكن موجودة
-    os.makedirs("logs", exist_ok=True)
-    
-    app.state.start_time = time.time()
-    app.state.request_count = 0
-    app.state.ai = SmartG4F()
-    
-    logger.info(f"✅ Loaded {len(SAFE_PROVIDERS)} safe providers")
-    logger.info(f"✅ Model: {MODEL}")
-    logger.info(f"✅ Max retries: {MAX_RETRIES}")
-    logger.info(f"✅ Timeout: {TIMEOUT}s")
-    logger.info("=" * 60)
-    
-    yield
-    
-    # Shutdown
-    logger.info("🛑 Shutting down SmartG4F API...")
-
-app = FastAPI(
-    title="SmartG4F API",
-    description="API خادم شامل لـ g4f بدون قيود",
-    version="2.0.0",
-    docs_url="/docs",
-    redoc_url="/redoc",
-    lifespan=lifespan
-)
-
-# ============================================================
-# CORS - مفتوح بالكامل
-# ============================================================
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # كلOrigins مسموحة
-    allow_credentials=True,
-    allow_methods=["*"],  # كل Methods مسموحة
-    allow_headers=["*"],  # كل Headers مسموحة
-    expose_headers=["*"]
-)
-
-# ============================================================
-# Middleware للتتبع والـ Logging
-# ============================================================
-@app.middleware("http")
-async def log_requests(request: Request, call_next):
-    """تسجيل كل طلب"""
-    request_id = str(uuid.uuid4())[:8]
-    start_time = time.time()
-    
-    # إضافة Request ID للـ Headers
-    request.state.request_id = request_id
-    
-    client_ip = get_client_ip(request)
-    
-    logger.info(
-        f"📥 [{request_id}] {request.method} {request.url.path} | "
-        f"IP: {client_ip}"
-    )
-    
-    try:
-        response = await call_next(request)
-        process_time = time.time() - start_time
-        
-        logger.info(
-            f"📤 [{request_id}] Status: {response.status_code} | "
-            f"Time: {process_time:.3f}s"
-        )
-        
-        # إضافة Headers للاستجابة
-        response.headers["X-Request-ID"] = request_id
-        response.headers["X-Process-Time"] = str(round(process_time, 3))
-        
-        return response
-        
-    except Exception as e:
-        process_time = time.time() - start_time
-        logger.error(
-            f"💥 [{request_id}] Error: {str(e)[:100]} | "
-            f"Time: {process_time:.3f}s"
-        )
-        raise
+class ChatRequest(BaseModel):
+    model: str = MODEL
+    messages: list[Message]
 
-# ============================================================
-# نقاط النهاية (Endpoints)
-# ============================================================
 
 @app.get("/")
 async def home():
-    """الصفحة الرئيسية"""
-    stats = app.state.ai.get_stats()
-    return {
-        "name": "SmartG4F API",
-        "version": "2.0.0",
-        "status": "running",
-        "uptime": stats["uptime_human"],
-        "providers": {
-            "safe": len(SAFE_PROVIDERS),
-            "available": stats["available_providers"],
-            "good": stats["good_providers"],
-            "bad": stats["bad_providers"]
-        },
-        "statistics": {
-            "total_requests": stats["total_requests"],
-            "success_rate": f"{stats['success_rate']}%",
-            "avg_response_time": f"{stats['avg_response_time']:.3f}s"
-        },
-        "proxy_configured": get_random_proxy() is not None,
-        "documentation": "/docs",
-        "health": "/health",
-        "metrics": "/metrics"
-    }
 
-@app.get("/health")
-async def health_check():
-    """فحص حالة الخادم"""
-    stats = app.state.ai.get_stats()
-    
-    status = "healthy"
-    if stats["bad_providers"] > len(SAFE_PROVIDERS) * 0.5:
-        status = "degraded"
-    if stats["success_rate"] < 30:
-        status = "unhealthy"
-    
     return {
-        "status": status,
-        "timestamp": datetime.now().isoformat(),
-        "uptime": stats["uptime_human"],
-        "providers": {
-            "total_safe": len(SAFE_PROVIDERS),
-            "available": stats["available_providers"],
-            "good": stats["good_providers"],
-            "bad": stats["bad_providers"]
-        },
-        "requests": {
-            "total": stats["total_requests"],
-            "successful": stats["successful_requests"],
-            "failed": stats["failed_requests"],
-            "success_rate": stats["success_rate"]
-        }
+        "status": "running",
+        "providers": len(SAFE_PROVIDERS)
     }
 
-@app.get("/metrics")
-async def get_metrics():
-    """الحصول على الإحصائيات المفصلة"""
-    stats = app.state.ai.get_stats()
-    return stats
 
-@app.get("/providers")
-async def list_providers():
-    """قائمة جميع المزودات المتاحين"""
-    return {
-        "safe_providers": [p.__name__ for p in SAFE_PROVIDERS],
-        "good_providers": [p.__name__ for p in app.state.ai.good],
-        "bad_providers": list(app.state.ai.bad.keys()),
-        "provider_stats": app.state.ai.provider_stats
-    }
+# =========================
+# OpenAI Endpoint
+# =========================
 
 @app.post("/v1/chat/completions")
 async def chat_completions(
-    request: ChatCompletionRequest,
-    authorization: Optional[str] = Header(None)
+    request: ChatRequest,
+    authorization: str = Header(None)
 ):
-    """
-    نقطة نهاية الإكمال المحادث - متوافق مع OpenAI API
-    """
-    # التحقق من المفتاح (اختياري)
-    if os.environ.get("MY_PROJECT_API_KEY"):
-        verify_api_key(authorization)
-    
-    # تحويل الرسائل إلى prompt واحد
-    prompt = "\n".join([
-        f"{msg.role}: {msg.content}" 
-        for msg in request.messages
-    ])
-    
-    logger.info(f"💬 Chat request | Model: {request.model} | Messages: {len(request.messages)}")
-    
-    # إرسال الطلب
-    result = app.state.ai.ask(
-        prompt=prompt,
-        temperature=request.temperature,
-        max_tokens=request.max_tokens,
-        stream=request.stream
+
+    # التحقق من المفتاح
+    if OPENAI_API_KEY:
+
+        if not authorization:
+            raise HTTPException(
+                status_code=401,
+                detail="Missing Authorization header"
+            )
+
+        token = authorization.replace("Bearer ", "")
+
+        if token != OPENAI_API_KEY:
+            raise HTTPException(
+                status_code=401,
+                detail="Invalid API key"
+            )
+
+    result = ai.ask(
+        [m.dict() for m in request.messages]
     )
-    
-    if result.get("success"):
-        return {
-            "id": f"chatcmpl-{result['request_id']}",
-            "object": "chat.completion",
-            "created": int(time.time()),
-            "model": request.model,
-            "choices": [
-                {
-                    "index": 0,
-                    "message": {
-                        "role": "assistant",
-                        "content": result.get("response")
-                    },
-                    "finish_reason": "stop"
-                }
-            ],
-            "usage": {
-                "prompt_tokens": len(prompt.split()),
-                "completion_tokens": result.get("tokens_used", 0),
-                "total_tokens": len(prompt.split()) + result.get("tokens_used", 0)
-            },
-            "provider": result.get("provider"),
-            "request_id": result.get("request_id"),
-            "response_time": result.get("response_time")
-        }
-    else:
+
+    if not result["success"]:
+
         raise HTTPException(
             status_code=500,
-            detail={
-                "error": {
-                    "message": result.get("error", "Failed to generate response"),
-                    "type": "api_error",
-                    "code": "GENERATION_FAILED",
-                    "request_id": result.get("request_id")
-                }
-            }
+            detail=result
         )
 
-@app.post("/v1/completions")
-async def completions(
-    request: CompletionRequest,
-    authorization: Optional[str] = Header(None)
-):
-    """نقطة نهاية الإكمال النصي"""
-    if os.environ.get("MY_PROJECT_API_KEY"):
-        verify_api_key(authorization)
-    
-    logger.info(f"✍️ Completion request | Model: {request.model}")
-    
-    results = []
-    
-    for i in range(request.n):
-        result = app.state.ai.ask(
-            prompt=request.prompt,
-            temperature=request.temperature,
-            max_tokens=request.max_tokens
-        )
-        
-        if result.get("success"):
-            results.append({
-                "text": result.get("response"),
-                "index": i,
-                "finish_reason": "stop"
-            })
-        else:
-            results.append({
-                "text": "",
-                "index": i,
-                "finish_reason": "error",
-                "error": result.get("error")
-            })
-    
-    return {
-        "id": f"comp-{str(uuid.uuid4())[:8]}",
-        "object": "text_completion",
-        "created": int(time.time()),
-        "model": request.model,
-        "choices": results,
-        "usage": {
-            "prompt_tokens": len(request.prompt.split()),
-            "total_tokens": sum(len(r.get("text", "").split()) for r in results)
-        }
-    }
+    response_text = result["response"]
 
-@app.post("/v1/embeddings")
-async def embeddings(
-    request: EmbeddingRequest,
-    authorization: Optional[str] = Header(None)
-):
-    """نقطة نهاية التضميد"""
-    if os.environ.get("MY_PROJECT_API_KEY"):
-        verify_api_key(authorization)
-    
-    inputs = [request.input] if isinstance(request.input, str) else request.input
-    
-    embeddings = []
-    for i, text in enumerate(inputs):
-        # توليد embedding وهمي (لأن g4f لا يدعم embeddings رسمياً)
-        embedding = [
-            random.uniform(-1, 1) for _ in range(1536)
-        ]
-        embeddings.append({
-            "object": "embedding",
-            "embedding": embedding,
-            "index": i
-        })
-    
     return {
-        "object": "list",
-        "data": embeddings,
+        "id": f"chatcmpl-{uuid.uuid4().hex}",
+        "object": "chat.completion",
+        "created": int(time.time()),
         "model": request.model,
-        "usage": {
-            "prompt_tokens": sum(len(t.split()) for t in inputs),
-            "total_tokens": sum(len(t.split()) for t in inputs)
-        }
-    }
-
-@app.get("/models")
-async def list_models():
-    """قائمة النماذج المتاحة"""
-    return {
-        "object": "list",
-        "data": [
-            {
-                "id": "gpt-4o-mini",
-                "object": "model",
-                "created": 20240101,
-                "owned_by": "openai"
-            },
-            {
-                "id": "gpt-4o",
-                "object": "model",
-                "created": 20240101,
-                "owned_by": "openai"
-            },
-            {
-                "id": "gpt-3.5-turbo",
-                "object": "model",
-                "created": 20240101,
-                "owned_by": "openai"
-            },
+        "choices": [
             {
-                "id": "claude-3-opus",
-                "object": "model",
-                "created": 20240101,
-                "owned_by": "anthropic"
-            },
-            {
-                "id": "claude-3-sonnet",
-                "object": "model",
-                "created": 20240101,
-                "owned_by": "anthropic"
+                "index": 0,
+                "message": {
+                    "role": "assistant",
+                    "content": response_text
+                },
+                "finish_reason": "stop"
             }
-        ]
+        ],
+        "usage": {
+            "prompt_tokens": 0,
+            "completion_tokens": 0,
+            "total_tokens": 0
+        }
     }
 
-@app.post("/reset-stats")
-async def reset_statistics(authorization: Optional[str] = Header(None)):
-    """إعادة تعيين الإحصائيات"""
-    if os.environ.get("MY_PROJECT_API_KEY"):
-        verify_api_key(authorization)
-    
-    app.state.ai.stats = {
-        "total_requests": 0,
-        "successful_requests": 0,
-        "failed_requests": 0,
-        "total_tokens_used": 0,
-        "avg_response_time": 0,
-        "start_time": time.time()
-    }
-    app.state.ai.error_log.clear()
-    
-    return {"message": "Statistics reset successfully"}
-
-@app.post("/reset-providers")
-async def reset_providers(authorization: Optional[str] = Header(None)):
-    """إعادة تعيين قائمة Providers"""
-    if os.environ.get("MY_PROJECT_API_KEY"):
-        verify_api_key(authorization)
-    
-    app.state.ai.good.clear()
-    app.state.ai.bad.clear()
-    app.state.ai.provider_stats.clear()
-    
-    return {"message": "Providers reset successfully"}
-
-# ============================================================
-# نقطة النهاية للتدفق (Streaming)
-# ============================================================
-async def generate_stream_response(request_id: str, provider: str, text: str, response_time: float):
-    """توليد الاستجابة المتدفقة"""
-    import json
-    
-    # إرسال بداية الاستجابة
-    chunk_id = f"chatcmpl-{request_id}"
-    created = int(time.time())
-    
-    yield f"data: {json.dumps({'id': chunk_id, 'object': 'chat.completion.chunk', 'created': created, 'model': MODEL, 'choices': [{'index': 0, 'delta': {'role': 'assistant'}, 'finish_reason': None}]})}\n\n"
-    
-    # تقسيم النص لكلمات
-    words = text.split()
-    for i, word in enumerate(words):
-        delta = {'content': word + ' '}
-        yield f"data: {json.dumps({'id': chunk_id, 'object': 'chat.completion.chunk', 'created': created, 'model': MODEL, 'choices': [{'index': 0, 'delta': delta, 'finish_reason': None}]})}\n\n"
-        await asyncio.sleep(0.01)  # تأخير بسيط للمحاكاة
-    
-    # إرسال نهاية الاستجابة
-    yield f"data: {json.dumps({'id': chunk_id, 'object': 'chat.completion.chunk', 'created': created, 'model': MODEL, 'choices': [{'index': 0, 'delta': {}, 'finish_reason': 'stop'}]})}\n\n"
-    
-    # إشعار النهاية
-    yield "data: [DONE]\n\n"
-
-@app.post("/v1/chat/completions/stream")
-async def chat_completions_stream(
-    request: ChatCompletionRequest,
-    authorization: Optional[str] = Header(None)
-):
-    """نقطة نهاية الإكمال المتدفق"""
-    if os.environ.get("MY_PROJECT_API_KEY"):
-        verify_api_key(authorization)
-    
-    prompt = "\n".join([
-        f"{msg.role}: {msg.content}" 
-        for msg in request.messages
-    ])
-    
-    logger.info(f"🌊 Stream request | Model: {request.model}")
-    
-    result = app.state.ai.ask(
-        prompt=prompt,
-        temperature=request.temperature,
-        max_tokens=request.max_tokens
-    )
-    
-    if result.get("success"):
-        return StreamingResponse(
-            generate_stream_response(
-                request_id=result['request_id'],
-                provider=result['provider'],
-                text=result['response'],
-                response_time=result['response_time']
-            ),
-            media_type="text/event-stream",
-            headers={
-                "Cache-Control": "no-cache",
-                "Connection": "keep-alive",
-                "X-Request-ID": result['request_id'],
-                "X-Provider": result['provider']
-            }
-        )
-    else:
-        raise HTTPException(
-            status_code=500,
-            detail=f"Failed to generate response: {result.get('error')}"
-        )
 
-# ============================================================
-# تشغيل الخادم
-# ============================================================
 if __name__ == "__main__":
-    # إعدادات Environment
-    port = int(os.environ.get("PORT", 7860))
-    host = os.environ.get("HOST", "0.0.0.0")
-    workers = int(os.environ.get("WORKERS", 1))
-    
-    logger.info("=" * 60)
-    logger.info(f"🌐 Starting SmartG4F API on {host}:{port}")
-    logger.info(f"📚 Documentation: http://localhost:{port}/docs")
-    logger.info("=" * 60)
-    
+
     uvicorn.run(
-        "main:app",
-        host=host,
-        port=port,
-        workers=workers,
-        log_level="info",
-        access_log=True,
-        reload=False  # تعطيل Reload في الإنتاج
-    )
+        app,
+        host="0.0.0.0",
+        port=7860
+    )