Update app.py

app.py

@@ -1,260 +1,852 @@
+"""
+╔══════════════════════════════════════════════════════════════════╗
+║                    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
 
-from fastapi import FastAPI, HTTPException, Depends, Header
-from pydantic import BaseModel
+# 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
 import uvicorn
 
+# g4f Dependencies
 from g4f.client import Client
 from g4f.Provider import __providers__
 
 # ============================================================
-# إنشاء ملف config.json تلقائياً إذا لم يكن موجوداً
-# (تقرأه مكتبة g4f تلقائياً عند إنشاء Client)
+# إعدادات الـ Logging المحسّن
 # ============================================================
-CONFIG_PATH = "config.json"
+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)
 
-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)
-        print("[+] config.json auto-generated for Context7 MCP")
-    else:
-        print("[!] CONTEXT7_API_KEY not set; skipping config.json creation")
+# إعداد الـ 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] = []
 
-MODEL = "gpt-4o-mini"
+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)} بروكسي")
 
-MAX_RETRIES = 10
-TIMEOUT = 60
+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
 
-SAFE_PROVIDERS = []
+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
+
+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)}")
 
-print(f"[+] SAFE PROVIDERS: {len(SAFE_PROVIDERS)}")
-
-client = Client()
+# ============================================================
+# إنشاء ملف 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 المحسّن بالكامل
+# ============================================================
 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):
-        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, prompt):
+    """
+    نظام ذكي لإدارة 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]
         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": "No providers available"
+                    "success": False, 
+                    "error": error_msg,
+                    "request_id": request_id
                 }
-
+            
             provider = random.choice(pool)
-
-            print(f"[TRY {attempt+1}] {provider.__name__}")
-
+            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 ❌'}"
+            )
+            
             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=[
-                        {
-                            "role": "user",
-                            "content": prompt
-                        }
-                    ],
-                    timeout=TIMEOUT,
+                    messages=messages,
+                    temperature=temperature,
+                    max_tokens=max_tokens,
+                    timeout=TIMEOUT
                 )
-
+                
+                request_time = time.time() - request_start
+                
+                # استخراج النص
                 text = response.choices[0].message.content
-
+                
                 if not text:
-                    raise Exception("Empty response")
-
-                if provider not in self.good:
-                    self.good.append(provider)
-
-                return {
+                    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 = {
                     "success": True,
+                    "request_id": request_id,
                     "provider": provider.__name__,
-                    "response": text
+                    "response": text,
+                    "response_time": round(request_time, 3),
+                    "tokens_used": len(text.split()),
+                    "proxy_used": bool(current_proxy)
                 }
-
+                
+                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:
-                err = str(e).lower()
-
-                traceback.print_exc()
-
-                errors.append({
+                error_str = str(e)
+                error_lower = error_str.lower()
+                request_time = time.time() - start_time
+                
+                # تسجيل الخطأ
+                error_entry = {
+                    "time": datetime.now().isoformat(),
                     "provider": provider.__name__,
-                    "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)
-
+                    "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)
+                    
                 else:
-                    self.mark_bad(provider, 180)
-
+                    cooldown = random.randint(180, 300)
+                    sleep_time = random.randint(2, 5)
+                    time.sleep(sleep_time)
+                
+                self.mark_bad(provider, cooldown)
                 continue
-
+        
+        # فشل جميع المحاولات
+        with self.lock:
+            self.stats["failed_requests"] += 1
+        
+        logger.error(f"🚫 [{request_id}] All {MAX_RETRIES} attempts failed")
+        
         return {
             "success": False,
-            "errors": errors
+            "request_id": request_id,
+            "error": f"Failed after {MAX_RETRIES} attempts",
+            "errors": errors,
+            "total_time": round(time.time() - start_time, 3)
         }
 
-
-app = FastAPI()
-
-ai = SmartG4F()
-
-
 # ============================================================
-# التعديل الجديد: هيكل بيانات متوافق مع نمط OpenAI v1
+# نماذج Pydantic للتحقق من البيانات
 # ============================================================
-class OpenAIQuery(BaseModel):
-    model: str
-    messages: list
-    temperature: float = 0.7
+class Message(BaseModel):
+    """نموذج رسالة واحدة"""
+    role: str = Field(..., pattern="^(system|user|assistant)$")
+    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]]
 
 # ============================================================
-# نظام الحماية — Bearer Token
+# نظام الحماية - بدون Rate Limiting
 # ============================================================
-def verify_api_key(authorization: str = Header(None)):
+def verify_api_key(authorization: Optional[str] = Header(None)) -> bool:
+    """التحقق من مفتاح API"""
     expected_key = os.environ.get("MY_PROJECT_API_KEY")
+    
     if not expected_key:
-        raise HTTPException(
-            status_code=500,
-            detail="Server misconfiguration: MY_PROJECT_API_KEY not set"
-        )
-
+        # إذا لم يتم تعيين مفتاح، نسمح بالوصول مع تحذير
+        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"
+            status_code=403, 
+            detail="❌ Missing Authorization header"
         )
-
+    
     if not authorization.startswith("Bearer "):
         raise HTTPException(
-            status_code=403,
-            detail="Invalid authorization header format. Expected: Bearer <token>"
+            status_code=403, 
+            detail="❌ Invalid authorization header format. Use: Bearer <token>"
         )
-
-    token = authorization.split(" ", 1)[1] if " " in authorization else ""
+    
+    token = authorization.split(" ", 1)[1]
+    
     if token != expected_key:
         raise HTTPException(
-            status_code=403,
-            detail="Invalid API key"
+            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
+
+# ============================================================
+# نقاط النهاية (Endpoints)
+# ============================================================
 
 @app.get("/")
 async def home():
+    """الصفحة الرئيسية"""
+    stats = app.state.ai.get_stats()
     return {
+        "name": "SmartG4F API",
+        "version": "2.0.0",
         "status": "running",
-        "providers": len(SAFE_PROVIDERS)
+        "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"]
+        }
     }
 
+@app.get("/metrics")
+async def get_metrics():
+    """الحصول على الإحصائيات المفصلة"""
+    stats = app.state.ai.get_stats()
+    return stats
 
-# ============================================================
-# التعديل الجديد: المسار والرد المتوافق مع الواجهة الخارجية ونمط v1
-# ============================================================
-@app.post("/v1/chat/completions", dependencies=[Depends(verify_api_key)])
-async def ask_v1(query: OpenAIQuery):
-    # سحب نص آخر رسالة أرسلها المستخدم في الواجهة
-    if query.messages:
-        last_message = query.messages[-1].get("content", "")
-    else:
-        last_message = ""
-        
-    # تمرير السؤال لمنطق المعالجة والـ Providers الذكي وسيرفر Context7
-    result = ai.ask(last_message)
+@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
+    }
+
+@app.post("/v1/chat/completions")
+async def chat_completions(
+    request: ChatCompletionRequest,
+    authorization: Optional[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
+    )
     
-    # تنسيق الرد بالشكل القياسي المتوافق مع OpenAI لتفهمه الواجهة مباشرة
     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")
@@ -262,19 +854,266 @@ async def ask_v1(query: OpenAIQuery):
                     "finish_reason": "stop"
                 }
             ],
-            "model": query.model,
-            "provider": result.get("provider")
+            "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:
         raise HTTPException(
-            status_code=500, 
-            detail="Failed to generate response from available providers"
+            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")
+                }
+            }
+        )
+
+@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)
+        }
+    }
+
+@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,
+        "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"
+            },
+            {
+                "id": "claude-3-opus",
+                "object": "model",
+                "created": 20240101,
+                "owned_by": "anthropic"
+            },
+            {
+                "id": "claude-3-sonnet",
+                "object": "model",
+                "created": 20240101,
+                "owned_by": "anthropic"
+            }
+        ]
+    }
+
+@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(
-        app,
-        host="0.0.0.0",
-        port=7860
+        "main:app",
+        host=host,
+        port=port,
+        workers=workers,
+        log_level="info",
+        access_log=True,
+        reload=False  # تعطيل Reload في الإنتاج
     )