Update app.py

app.py

@@ -4,15 +4,14 @@ import time
 import logging
 import subprocess
 import re
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.responses import StreamingResponse, JSONResponse
-from fastapi.routing import APIRoute
 from pydantic import BaseModel
 import g4f
 
 logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("g4f-smart-router")
+logger = logging.getLogger("g4f-gateway")
 
 # =====================================================
 # COOKIES
@@ -56,58 +55,142 @@ COOKIE_STATUS = load_cookies()
 # =====================================================
 # PROVIDERS
 # =====================================================
-def get_provider(name: str):
+def _get_provider(name: str):
     try:
-        return getattr(g4f.Provider, name)
-    except:
+        p = getattr(g4f.Provider, name, None)
+        return p if p and callable(p) else None
+    except Exception:
         return None
 
-REAL_PROVIDERS: Dict[str, Any] = {
-    "Perplexity": get_provider("Perplexity") or get_provider("PerplexityAi"),
-    "Copilot":    get_provider("Copilot"),
-    "Qwen":       get_provider("Qwen"),
-    "Blackbox":   get_provider("Blackbox"),
-    "DeepSeek":   get_provider("DeepSeek"),
-    "HuggingFace": get_provider("HuggingFace"),
-    "Cloudflare": get_provider("Cloudflare"),
-    "You":        get_provider("You"),
-    "Bing":       get_provider("Bing"),
-}
-REAL_PROVIDERS = {k: v for k, v in REAL_PROVIDERS.items() if v}
+PRIORITY_PROVIDERS = [
+    "Qwen", "Blackbox", "DeepSeek", "Copilot", "Perplexity",
+    "PerplexityAi", "You", "HuggingFace", "Cloudflare", "Bing",
+    "BingChat", "BlackboxPro", "DeepInfra", "OneApi",
+]
+
+REAL_PROVIDERS: Dict[str, Any] = {}
+for pname in PRIORITY_PROVIDERS:
+    p = _get_provider(pname)
+    if p:
+        REAL_PROVIDERS[pname] = p
+
+logger.info(f"Available providers: {list(REAL_PROVIDERS.keys())}")
 
 # =====================================================
-# MODELS
+# MODELS — من g4f.models
 # =====================================================
-# الأسماء الصحيحة في g4f v7.5.5
-QWEN_WORKING_MODELS = [
-    "qwen-3-235b",
-    "qwen-3-32b",
-    "qwen-3-30b",
-    "qwen-3-14b",
-    "qwen-3-4b",
-    "qwen-2.5-72b",
-]
+def _discover_models() -> Dict[str, str]:
+    models = {}
+    try:
+        for attr in dir(g4f.models):
+            val = getattr(g4f.models, attr)
+            if isinstance(val, str) and not attr.startswith('_') and len(val) > 1:
+                models[attr] = val
+    except Exception as e:
+        logger.warning(f"Failed to discover g4f models: {e}")
+    return models
 
-PROVIDER_MODELS_FALLBACK: Dict[str, List[str]] = {
-    "Perplexity":  ["sonar", "sonar-pro", "gpt-4o", "llama-3"],
-    "Copilot":     ["gpt-4o", "gpt-4", "turbo"],
-    "Qwen":        QWEN_WORKING_MODELS,
-    "Blackbox":    ["gpt-4o", "claude-3", "gemini-pro", "llama-3"],
-    "DeepSeek":    ["deepseek-chat", "deepseek-coder"],
-    "HuggingFace": ["meta-llama", "mistral", "qwen", "gemma"],
-    "Cloudflare":  ["llama-3", "mistral", "qwen"],
-    "You":         ["gpt-4o", "claude", "llama-3"],
-    "Bing":        ["gpt-4o", "gpt-4"],
-}
+G4F_MODELS = _discover_models()
+
+def _find_model(patterns: list) -> str:
+    for pat in patterns:
+        for key, val in G4F_MODELS.items():
+            if pat.lower() == val.lower():
+                return val
+        for key, val in G4F_MODELS.items():
+            if pat.lower().replace('-', '_') == key.lower():
+                return val
+    return patterns[0]
 
-# كل نماذج Claude تُحوَّل إلى أفضل نموذج Qwen متاح في g4f
 CLAUDE_MODEL_MAP: Dict[str, str] = {
-    "claude-opus-4-6":   "qwen-3-235b",
-    "claude-sonnet-4-6": "qwen-3-32b",
-    "claude-haiku-4-5":  "qwen-3-14b",
-    "claude-sonnet-4-5": "qwen3.6-plus",
+    "claude-opus-4-6":          _find_model(["qwen-3-235b", "qwen3-235b", "qwen-3-235b-a22b"]),
+    "claude-opus-4-5":          _find_model(["qwen-3-235b", "qwen3-235b"]),
+    "claude-sonnet-4-6":        _find_model(["qwen-3-32b", "qwen3-32b", "qwen-plus"]),
+    "claude-sonnet-4-5":        _find_model(["qwen-3-32b", "qwen3-32b"]),
+    "claude-haiku-4-6":         _find_model(["qwen-3-14b", "qwen3-14b", "qwen-turbo"]),
+    "claude-haiku-4-5":         _find_model(["qwen-3-14b", "qwen3-14b"]),
+    "claude-haiku-4-5-20251001": _find_model(["qwen-3-14b", "qwen3-14b"]),
 }
 
+# =====================================================
+# ERROR FILTER — كشف الردود الخاطئة
+# =====================================================
+_ERROR_PATTERNS = [
+    re.compile(r"<html", re.IGNORECASE),
+    re.compile(r"<!DOCTYPE", re.IGNORECASE),
+    re.compile(r"<span style", re.IGNORECASE),
+    re.compile(r"Model not found", re.IGNORECASE),
+    re.compile(r"<[^>]+>'NoneType'", re.IGNORECASE),
+    re.compile(r"403\s+Forbidden", re.IGNORECASE),
+    re.compile(r"429\s+Too Many Requests", re.IGNORECASE),
+    re.compile(r"502\s+Bad Gateway", re.IGNORECASE),
+    re.compile(r"cloudflare", re.IGNORECASE),
+    re.compile(r"captcha", re.IGNORECASE),
+    re.compile(r"['\"]code['\"]\s*:\s*['\"](Forbidden|Error|Not_Found)['\"]", re.IGNORECASE),
+    re.compile(r"success.*[Ff]alse", re.IGNORECASE),
+]
+
+def is_invalid_response(text: str) -> bool:
+    if not text or len(text.strip()) < 5:
+        return True
+    lower = text.strip().lower()
+    # JSON error check
+    if lower.startswith('{'):
+        try:
+            d = json.loads(text)
+            if isinstance(d, dict):
+                data = d.get("data", d)
+                if isinstance(data, dict):
+                    code = data.get("code") or data.get("details", "").strip()
+                    if code in ("Not_Found", "Forbidden", "Error"):
+                        return True
+                if isinstance(d.get("success"), bool) and not d["success"]:
+                    return True
+                if any(k in d.lower() for k in ("error", "failed", "denied")):
+                    return True
+        except Exception:
+            pass
+    for pat in _ERROR_PATTERNS:
+        if pat.search(text):
+            return True
+    return False
+
+# =====================================================
+# STRIP THINKING
+# =====================================================
+def strip_thinking(text: str) -> str:
+    text = re.sub(r'', '', text, flags=re.DOTALL)
+    text = re.sub(r'<thinking>.*?</thinking>', '', text, flags=re.DOTALL)
+    # trailing thinking block
+    text = re.sub(r'[\n\r]*$', '', text, flags=re.MULTILINE)
+    text = text.strip()
+    if text == "":
+        return "⚠️ Provider returned an empty response"
+    return text
+
+# =====================================================
+# CLEAN CHUNK
+# =====================================================
+def clean_chunk(chunk: Any) -> str:
+    if chunk is None:
+        return ""
+    if isinstance(chunk, str):
+        return chunk
+    if isinstance(chunk, dict):
+        if "choices" in chunk and chunk.get("choices"):
+            Ch = chunk["choices"]
+            if isinstance(Ch, list) and len(Ch) > 0:
+                delta = Ch[0].get("delta", {})
+                content = delta.get("content") or delta.get("text") or ""
+                return content if isinstance(content, str) else ""
+        if "content" in chunk:
+            c = chunk["content"]
+            return str(c) if isinstance(c, str) else ""
+        if "text" in chunk:
+            t = chunk["text"]
+            return str(t) if isinstance(t, str) else ""
+    return str(chunk)
+
 # =====================================================
 # TOOLS
 # =====================================================
@@ -117,7 +200,7 @@ AVAILABLE_TOOLS = [
         "description": "قراءة محتوى ملف",
         "input_schema": {
             "type": "object",
-            "properties": {"path": {"type": "string", "description": "مسار الملف"}},
+            "properties": {"path": {"type": "string"}},
             "required": ["path"]
         }
     },
@@ -127,8 +210,8 @@ AVAILABLE_TOOLS = [
         "input_schema": {
             "type": "object",
             "properties": {
-                "path":    {"type": "string", "description": "مسار الملف"},
-                "content": {"type": "string", "description": "المحتوى"}
+                "path": {"type": "string"},
+                "content": {"type": "string"}
             },
             "required": ["path", "content"]
         }
@@ -138,7 +221,7 @@ AVAILABLE_TOOLS = [
         "description": "عرض محتوى مجلد",
         "input_schema": {
             "type": "object",
-            "properties": {"path": {"type": "string", "description": "المسار", "default": "."}},
+            "properties": {"path": {"type": "string", "default": "."}},
             "required": []
         }
     },
@@ -147,7 +230,7 @@ AVAILABLE_TOOLS = [
         "description": "تشغيل أمر shell",
         "input_schema": {
             "type": "object",
-            "properties": {"command": {"type": "string", "description": "الأمر"}},
+            "properties": {"command": {"type": "string"}},
             "required": ["command"]
         }
     },
@@ -156,7 +239,7 @@ AVAILABLE_TOOLS = [
         "description": "حذف ملف",
         "input_schema": {
             "type": "object",
-            "properties": {"path": {"type": "string", "description": "مسار الملف"}},
+            "properties": {"path": {"type": "string"}},
             "required": ["path"]
         }
     },
@@ -167,414 +250,588 @@ def execute_tool(name: str, inp: Dict[str, Any]) -> str:
         if name == "read_file":
             p = inp.get("path", "")
             if not os.path.exists(p):
-                return f"❌ الملف غير موجود: {p}"
+                return f"Error: file not found: {p}"
             with open(p, "r", encoding="utf-8", errors="replace") as f:
-                return f.read() or "(الملف فارغ)"
-
+                return f.read() or "(empty file)"
         elif name == "write_file":
-            p = inp.get("path", "")
-            c = inp.get("content", "")
+            p, c = inp.get("path", ""), inp.get("content", "")
             os.makedirs(os.path.dirname(os.path.abspath(p)), exist_ok=True)
             with open(p, "w", encoding="utf-8") as f:
                 f.write(c)
-            return f"✅ تم حفظ الملف: {p}"
-
+            return f"Written {len(c)} bytes to {p}"
         elif name == "list_directory":
             p = inp.get("path", ".")
             if not os.path.exists(p):
-                return f"❌ المسار غير موجود: {p}"
+                return f"Error: path not found: {p}"
             items = sorted(os.listdir(p))
-            lines = [("📁 " if os.path.isdir(os.path.join(p, i)) else "📄 ") + i for i in items]
-            return "\n".join(lines) or "(فارغ)"
-
+            lines = [("dir  " if os.path.isdir(os.path.join(p, i)) else "file ") + i for i in items]
+            return "\n".join(lines) or "(empty)"
         elif name == "run_command":
             cmd = inp.get("command", "")
             r = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=30)
             out = (r.stdout + r.stderr).strip()
-            return out or "(لا يوجد إخراج)"
-
+            return out or "(no output)"
         elif name == "delete_file":
             p = inp.get("path", "")
             if not os.path.exists(p):
-                return f"❌ الملف غير موجود: {p}"
+                return f"Error: file not found: {p}"
             os.remove(p)
-            return f"✅ تم الحذف: {p}"
-
-        return f"❌ أداة غير معروفة: {name}"
+            return f"Deleted: {p}"
     except Exception as e:
-        return f"❌ خطأ: {e}"
+        return f"Tool error: {e}"
+    return f"Unknown tool: {name}"
 
 # =====================================================
-# SYSTEM PROMPT
+# SYSTEM PROMPT — بتنسيق tool_use صحيح
 # =====================================================
-SYSTEM_PROMPT = """أنت مساعد ذكي قادر على تنفيذ مهام حقيقية.
-عندما تحتاج لأداة اكتب بهذا الشكل فقط:
-<tool_use>{"name": "اسم_الأداة", "input": {"المعامل": "القيمة"}}</tool_use>
+SYSTEM_PROMPT = """You are a helpful AI assistant with access to tools.
+When you need to use a tool, respond with ONLY this JSON (no other text before or after):
+{"tool": "tool_name", "input": {"param": "value"}}
 
-الأدوات المتاحة: read_file، write_file، list_directory، run_command، delete_file
-نفّذ الطلب مباشرة بدون تردد."""
+Available tools: read_file, write_file, list_directory, run_command, delete_file.
+After receiving tool results, provide your final answer to the user."""
 
 # =====================================================
-# MODEL DISCOVERY
+# ASYNC EXECUTOR
 # =====================================================
-_PROVIDER_MODEL_CACHE: Dict[str, List[str]] = {}
-
-def _normalize(x: Any) -> List[str]:
-    if x is None: return []
-    if isinstance(x, dict): items = list(x.keys())
-    elif isinstance(x, (list, tuple, set)): items = list(x)
-    else: items = [x]
-    seen, out = set(), []
-    for m in [str(i).strip() for i in items if i]:
-        if m not in seen:
-            out.append(m)
-            seen.add(m)
-    return out
+def _get_executor():
+    import concurrent.futures
+    return concurrent.futures.ThreadPoolExecutor(max_workers=8)
 
-def discover_models(pobj: Any, pname: str) -> List[str]:
-    candidates = []
-    for attr in ("models", "model", "default_model", "available_models", "supported_models"):
-        try:
-            if hasattr(pobj, attr):
-                candidates += _normalize(getattr(pobj, attr))
-        except: pass
-    for fn in ("get_models", "models_list", "list_models"):
-        try:
-            if hasattr(pobj, fn):
-                candidates += _normalize(getattr(pobj, fn)())
-        except: pass
-    if not candidates:
-        candidates = PROVIDER_MODELS_FALLBACK.get(pname, ["gpt-4o"])
-    seen, out = set(), []
-    for m in candidates:
-        if m not in seen:
-            out.append(m)
-            seen.add(m)
-    return out
-
-# =====================================================
-# CACHE
-# =====================================================
-_CACHE: Dict[str, str] = {}
-_CACHE_TS: Dict[str, float] = {}
+_executor_cache = None
 
-def cache_get(key): return _CACHE.get(key)
-def cache_set(key, val):
-    _CACHE[key] = val
-    _CACHE_TS[key] = time.time()
+def get_executor():
+    global _executor_cache
+    if _executor_cache is None:
+        _executor_cache = _get_executor()
+    return _executor_cache
 
 # =====================================================
-# STREAM CLEANER
+# G4F CALL
 # =====================================================
-def clean_chunk(chunk) -> str:
-    try:
-        if isinstance(chunk, dict):
-            if "choices" in chunk and chunk["choices"]:
-                delta = chunk["choices"][0].get("delta", {})
-                return delta.get("content") or delta.get("text") or ""
-            return chunk.get("content") or chunk.get("text") or ""
-        if isinstance(chunk, str):
-            if chunk.strip().startswith("{"):
+async def g4f_call(messages: List[Dict], model: str, provider: str = None) -> str:
+    loop = asyncio.get_event_loop()
+    pool = get_executor()
+    
+    async def _call_sync():
+        # تحديد النموذج النهائي
+        target_model = CLAUDE_MODEL_MAP.get(model, model)
+        providers_to_try = []
+        
+        # الترتيب الأولوي: المزود المطلوب أو الافتراضي + فلاتر
+        if provider and provider in REAL_PROVIDERS:
+            providers_to_try.append((provider, target_model))
+            # إضافة مزودات أخرى في نفس النوع
+            base_name = provider.split('.')[0] if '.' in provider else provider
+            for pname in REAL_PROVIDERS:
+                if pname == provider or pname.startswith(base_name):
+                    providers_to_try.append((pname, target_model))
+        else:
+            # وضع غامض
+            for pname in REAL_PROVIDERS.keys():
+                providers_to_try.append((pname, target_model))
+        
+        seen = set()
+        for pobj, pm in providers_to_try:
+            key = f"{pobj.__name__}_{pm}"
+            if key in seen:
+                continue
+            seen.add(key)
+            
+            # محاولة النموذج نفسه أولاً
+            try:
+                result = g4f.ChatCompletion.create(
+                    model=pm,
+                    provider=pobj,
+                    messages=messages,
+                    stream=False,
+                )
+                text = str(result or "")
+                if is_invalid_response(text):
+                    continue
+                text = strip_thinking(text)
+                if text:
+                    logger.info(f"Provider success: {pobj.__name__} model={pm}")
+                    return text
+            except Exception as e:
+                logger.debug(f"Provider failed: {pobj.__name__} model={pm}: {e}")
+                continue
+        
+        # الفشل — المحاولين بـ fallback models
+        for pobj, pm in providers_to_try:
+            for fallback in ["gpt-4o", "gpt-4", "claude-3-haiku", "gpt-3.5-turbo"]:
+                key = f"{pobj.__name__}_{fallback}"
+                if key in seen:
+                    continue
+                seen.add(key)
                 try:
-                    d = json.loads(chunk)
-                    if "choices" in d and d["choices"]:
-                        return d["choices"][0].get("delta", {}).get("content", "")
-                    return d.get("content") or d.get("text") or ""
-                except: pass
-            return chunk.replace("\\n", "\n").replace("\\r", "\r").replace("\\t", "    ")
-        return str(chunk)
-    except Exception as e:
-        logger.warning(f"clean_chunk error: {e}")
-        return ""
-
-# =====================================================
-# SURGICAL VALIDATION (فحص مخرجات g4f لمنع كود الأخطاء التالفة)
-# =====================================================
-def is_invalid_response(text: str) -> bool:
-    """تحديد وحجب ردود الأخطاء الداخلية من g4f ومزوداتها قبل إرسالها للواجهة."""
-    if not text:
-        return True
-    t_lower = text.lower().strip()
-    # التحقق المباشر من الأخطاء كـ HTML span المرسلة بالصورة
-    if "<span" in t_lower and "color" in t_lower and ("red" in t_lower or "choices" in t_lower or "nonetype" in t_lower):
-        return True
-    if "nonetype" in t_lower and "choices" in t_lower:
-        return True
-    if "object has no attribute" in t_lower:
-        return True
-    if "error" in t_lower and "style=" in t_lower:
-        return True
-    if t_lower.startswith("<!doctype html") or t_lower.startswith("<html"):
-        return True
-    return False
+                    result = g4f.ChatCompletion.create(
+                        model=fallback,
+                        provider=pobj,
+                        messages=messages,
+                        stream=False,
+                    )
+                    text = str(result or "")
+                    if is_invalid_response(text):
+                        continue
+                    text = strip_thinking(text)
+                    if text:
+                        logger.info(f"Provider fallback success: {pobj.__name__} model={fallback}")
+                        return text
+                except Exception as e:
+                    logger.debug(f"Provider fallback failed: {pobj.__name__} model={fallback}: {e}")
+                    continue
+        
+        raise RuntimeError("All providers failed after trying fallback models too")
+    
+    return await loop.run_in_executor(pool, _call_sync)
 
 # =====================================================
-# CORE ASK
+# STREAMING G4F
 # =====================================================
-def ask(message: str, history: list, provider_name: str, model_name: str):
-    message = (message or "").strip()
-    if not message:
-        yield ""
-        return
-
-    model_name = CLAUDE_MODEL_MAP.get(model_name, model_name)
-    key = f"{provider_name}|{model_name}|{message}"
-    cached = cache_get(key)
-    if cached:
-        yield cached
-        return
-
-    msgs = []
-    try:
-        if history:
-            src = history[-40:] if isinstance(history[0], dict) else history[-20:]
-            for item in src:
-                if isinstance(item, dict):
-                    r, c = item.get("role"), item.get("content")
-                    if r and c:
-                        msgs.append({"role": str(r), "content": str(c)})
-                elif isinstance(item, (list, tuple)) and len(item) == 2:
-                    u, a = item
-                    if u: msgs.append({"role": "user", "content": str(u)})
-                    if a: msgs.append({"role": "assistant", "content": str(a)})
-    except Exception as e:
-        logger.warning(e)
-
-    msgs.append({"role": "user", "content": message})
-
-    fallback_order = [provider_name, "Perplexity", "Copilot", "Blackbox", "DeepSeek", "Bing", "You", "Qwen"]
-    used = []
-    for pname in fallback_order:
-        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_models(pobj, pname)
-        candidates = [model_name] + [x for x in _PROVIDER_MODEL_CACHE[pname] if x != model_name]
-        for m in candidates[:12]:
+async def g4f_stream(messages: List[Dict], model: str, provider: str = None) -> str:
+    loop = asyncio.get_event_loop()
+    pool = get_executor()
+    
+    async def _stream_sync():
+        target_model = CLAUDE_MODEL_MAP.get(model, model)
+        providers_to_try = []
+        
+        if provider and provider in REAL_PROVIDERS:
+            providers_to_try.append((provider, target_model))
+            base_name = provider.split('.')[0] if '.' in provider else provider
+            for pname in REAL_PROVIDERS:
+                if pname == provider or pname.startswith(base_name):
+                    providers_to_try.append((pname, target_model))
+        else:
+            for pname in REAL_PROVIDERS.keys():
+                providers_to_try.append((pname, target_model))
+        
+        seen = set()
+        for pobj, pm in providers_to_try:
+            key = f"{pobj.__name__}_{pm}"
+            if key in seen:
+                continue
+            seen.add(key)
+            
             try:
                 stream = g4f.ChatCompletion.create(
-                    model=m, provider=pobj, messages=msgs, stream=True
+                    model=pm,
+                    provider=pobj,
+                    messages=messages,
+                    stream=True,
                 )
-                text = ""
-                has_yielded = False
+                buffer = ""
                 for chunk in stream:
                     c = clean_chunk(chunk)
                     if c:
-                        temp_text = text + c
-                        # الفحص الجراحي قبل الإرسال لمنع ظهور كود HTML تالف في واجهة المستخدم
-                        if is_invalid_response(temp_text) or is_invalid_response(c):
-                            logger.warning(f"Rejected invalid response from provider {pname} (model: {m})")
-                            text = ""
-                            break
-                        text = temp_text
-                        yield text
-                        has_yielded = True
-                
-                # فحص نهائي للرد المجمع قبل تخزينه بالذاكرة المؤقتة (cache)
-                if text.strip() and not is_invalid_response(text):
-                    cache_set(key, text)
-                    return
-                else:
-                    if has_yielded:
-                        yield ""
+                        buffer += c
+                if is_invalid_response(buffer):
                     continue
+                text = strip_thinking(buffer)
+                if text:
+                    logger.info(f"Streaming success: {pobj.__name__} model={pm}")
+                    return text
             except Exception as e:
-                logger.warning(e)
+                logger.debug(f"Streaming failed: {pobj.__name__} model={pm}: {e}")
                 continue
-
-    yield "❌ فشل مع جميع المزودين."
+        
+        # fallback models
+        for pobj, _ in providers_to_try:
+            for fallback in ["gpt-4o", "gpt-4", "claude-3-haiku", "gpt-3.5-turbo"]:
+                key = f"{pobj.__name__}_{fallback}"
+                if key in seen:
+                    continue
+                seen.add(key)
+                try:
+                    stream = g4f.ChatCompletion.create(
+                        model=fallback,
+                        provider=pobj,
+                        messages=messages,
+                        stream=True,
+                    )
+                    buffer = ""
+                    for chunk in stream:
+                        c = clean_chunk(chunk)
+                        if c:
+                            buffer += c
+                    if is_invalid_response(buffer):
+                        continue
+                    text = strip_thinking(buffer)
+                    if text:
+                        logger.info(f"Streaming fallback success: {pobj.__name__} model={fallback}")
+                        return text
+                except Exception as e:
+                    logger.debug(f"Streaming fallback failed: {pobj.__name__} model={fallback}: {e}")
+                    continue
+        
+        raise RuntimeError("All provider streams failed after fallbacks")
+    
+    return await loop.run_in_executor(pool, _stream_sync)
 
 # =====================================================
 # AGENTIC LOOP
 # =====================================================
-TOOL_RE = re.compile(r"<tool_use>(.*?)</tool_use>", re.DOTALL)
-
-def agentic_ask(messages: List[Dict], tools: List[Dict] = None) -> str:
-    system = SYSTEM_PROMPT
-    if tools:
-        system += f"\n\nأدوات إضافية:\n{json.dumps(tools, ensure_ascii=False)}"
-
-    working = [{"role": "system", "content": system}] + list(messages)
-    max_iter = 8
-
-    for _ in range(max_iter):
-        last_user = ""
-        for m in reversed(working):
-            if m.get("role") == "user":
-                c = m.get("content", "")
-                last_user = c if isinstance(c, str) else str(c)
-                break
-
-        history = [m for m in working[:-1]]
-        full = ""
-        for chunk in ask(last_user, history, "Qwen", "claude-sonnet-4-6"):
-            full = chunk
-
-        if not full.strip():
-            return "❌ لم يأتِ رد."
-
-        matches = TOOL_RE.findall(full)
-        if not matches:
-            return full
-
-        results = []
-        for match in matches:
-            try:
-                td = json.loads(match.strip())
-                tname = td.get("name", "")
-                tinput = td.get("input", {})
-                logger.info(f"Tool: {tname} | Input: {tinput}")
-                result = execute_tool(tname, tinput)
-                results.append(f"[نتيجة {tname}]:\n{result}")
-            except Exception as e:
-                results.append(f"[خطأ في الأداة]: {e}")
-
-        working.append({"role": "assistant", "content": full})
+async def agentic_loop(messages: List[Dict], tools: List[Dict], model: str) -> tuple:
+    working = list(messages)
+    tool_calls_log = []
+    
+    if not any(m.get("role") == "system" for m in working):
+        working = [{"role": "system", "content": SYSTEM_PROMPT}] + working
+    
+    for iteration in range(6):
+        text = await g4f_call(working, model)
+        
+        # JSON request pattern
+        json_match = re.search(r'\{\s*"tool"\s*:\s*"([^"]+)"', text, re.DOTALL)
+        if not json_match:
+            logger.info(f"Iter {iteration}: No tool request found → final answer")
+            return text, tool_calls_log
+        
+        try:
+            tool_req = json.loads(json_match.group(0))
+            tname = tool_req.get("tool", "")
+            tinput = tool_req.get("input", {})
+        except json.JSONDecodeError as e:
+            logger.debug(f"Iter {iteration}: invalid JSON: {e}")
+            return text, tool_calls_log
+        
+        logger.info(f"[iter={iteration}] tool={tname}")
+        loop = asyncio.get_event_loop()
+        result = await loop.run_in_executor(get_executor(), execute_tool, tname, tinput)
+        
+        tool_id = f"toolu_{iteration:04d}"
+        tool_calls_log.append({
+            "id": tool_id,
+            "name": tname,
+            "input": tinput,
+            "result": result
+        })
+        
+        working.append({"role": "assistant", "content": text})
         working.append({
             "role": "user",
-            "content": "نتائج الأدوات:\n" + "\n\n".join(results) + "\n\nأكمل إجابتك للمستخدم."
+            "content": f"Tool result for {tname}:\n{result}\n\nNow provide your final answer."
         })
-
-    return full
+    
+    logger.warning(f"Iteration exhausted: {iteration}")
+    return text, tool_calls_log
 
 # =====================================================
 # FASTAPI
 # =====================================================
-app = FastAPI(title="G4F API")
+app = FastAPI(title="G4F Anthropic-compatible Gateway")
 API_KEY = os.getenv("API_KEY", "mysecretkey123")
 
-class ChatRequest(BaseModel):
-    message: str
-    provider: str = "Qwen"
-    model: str = "claude-sonnet-4-6"
-    history: List[Any] = []
-
-def verify(request: Request):
+def _verify(request: Request):
     auth = request.headers.get("Authorization", "")
     if auth.startswith("Bearer ") and auth[7:] == API_KEY:
-        return True
+        return
     if request.headers.get("X-API-Key", "") == API_KEY:
-        return True
+        return
     raise HTTPException(status_code=401, detail="Invalid or missing API key")
 
+# =====================================================
+# ROOT & HEALTH
+# =====================================================
 @app.api_route("/", methods=["GET", "HEAD"])
 async def root():
     return JSONResponse({
-        "message": "G4F API is running",
-        "model": "Qwen3 (claude-compatible)",
-        "endpoints": {
-            "GET /health": "فحص الخادم",
-            "GET /v1/models": "قائمة النماذج",
-            "POST /v1/messages": "Claude-compatible chat",
-            "POST /chat": "chat بسيط",
-            "POST /chat/stream": "streaming",
-            "GET /providers": "المزودون"
-        },
-        "status": "✅ running"
+        "status": "running",
+        "service": "G4F Anthropic compatible gateway",
+        "cookies": COOKIE_STATUS,
+        "providers": len(REAL_PROVIDERS),
+        "version": "7.5.6"
     })
 
 @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, req: ChatRequest):
-    verify(request)
-    full = ""
-    for chunk in ask(req.message, req.history, req.provider, req.model):
-        full = chunk
-    return JSONResponse({"response": full})
-
-@app.post("/chat/stream")
-async def chat_stream(request: Request, req: ChatRequest):
-    verify(request)
-    async def gen():
-        for chunk in ask(req.message, req.history, req.provider, req.model):
-            yield f"data: {json.dumps({'chunk': chunk})}\n\n"
-        yield "data: [DONE]\n\n"
-    return StreamingResponse(gen(), media_type="text/event-stream")
+    return {
+        "status": "ok",
+        "cookies": COOKIE_STATUS,
+        "providers": list(REAL_PROVIDERS.keys())
+    }
 
-@app.get("/providers")
-async def get_providers(request: Request):
-    verify(request)
-    info = {}
-    for pname, pobj in REAL_PROVIDERS.items():
-        if pname not in _PROVIDER_MODEL_CACHE:
-            _PROVIDER_MODEL_CACHE[pname] = discover_models(pobj, pname)
-        info[pname] = _PROVIDER_MODEL_CACHE[pname]
-    return JSONResponse({"providers": info})
+@app.get("/v1/models")
+async def list_models(request: Request):
+    _verify(request)
+    return JSONResponse({
+        "object": "list",
+        "data": [
+            {"id": "claude-opus-4-6", "object": "model", "created": 1710000000, "owned_by": "g4f"},
+            {"id": "claude-sonnet-4-6", "object": "model", "created": 1710000000, "owned_by": "g4f"},
+            {"id": "claude-haiku-4-6", "object": "model", "created": 1710000000, "owned_by": "g4f"},
+            {"id": "claude-haiku-4-5", "object": "model", "created": 1710000000, "owned_by": "g4f"},
+        ]
+    })
 
 # =====================================================
-# Anthropic-compatible endpoints
+# /v1/messages
 # =====================================================
-@app.get("/v1/models")
-async def list_models(request: Request):
-    verify(request)
-    return JSONResponse({"object": "list", "data": [
-        {"id": "claude-opus-4-6",   "object": "model", "owned_by": "anthropic"},
-        {"id": "claude-sonnet-4-6", "object": "model", "owned_by": "anthropic"},
-        {"id": "claude-haiku-4-5",  "object": "model", "owned_by": "anthropic"},
-    ]})
-
-@app.api_route("/v1/messages", methods=["POST"])
+@app.post("/v1/messages")
 async def messages_endpoint(request: Request):
-    verify(request)
-
+    _verify(request)
     body = await request.json()
-    model        = body.get("model", "claude-sonnet-4-6")
-    raw_messages = body.get("messages", [])
-    do_stream    = body.get("stream", False)
+    model = body.get("model", "claude-sonnet-4-6")
+    raw_msgs = body.get("messages", [])
+    do_stream = body.get("stream", False)
     client_tools = body.get("tools", [])
-
-    if not raw_messages:
+    system_body = body.get("system", "")
+    
+    if not raw_msgs:
         raise HTTPException(status_code=400, detail="messages required")
-
+    
+    # تنظيف الرسائل
+    def _content_to_str(content):
+        if isinstance(content, str):
+            return content
+        if isinstance(content, list):
+            parts = []
+            for block in content:
+                if not isinstance(block, dict):
+                    parts.append(str(block))
+                    continue
+                btype = block.get("type", "")
+                if btype == "text":
+                    parts.append(block.get("text", ""))
+                elif btype == "tool_result":
+                    rc = block.get("content", "")
+                    if isinstance(rc, list):
+                        rc = "\n".join(
+                            b.get("text", "") if isinstance(b, dict) else str(b)
+                            for b in rc
+                        )
+                    parts.append(f"[Tool result]: {rc}")
+                elif btype == "tool_use":
+                    pass
+                else:
+                    parts.append(str(block.get("text", block.get("content", ""))))
+            return "\n".join(p for p in parts if p)
+        return str(content)
+    
     clean_msgs = []
-    for m in raw_messages:
+    if system_body:
+        txt = _content_to_str(system_body)
+        if txt:
+            clean_msgs.append({"role": "system", "content": txt})
+    
+    for m in raw_msgs:
         role = m.get("role", "user")
-        content = m.get("content", "")
-        if isinstance(content, list):
-            text = " ".join(b.get("text", "") for b in content if isinstance(b, dict) and b.get("type") == "text")
-        else:
-            text = str(content)
-        clean_msgs.append({"role": role, "content": text})
-
-    all_tools = AVAILABLE_TOOLS + [t for t in client_tools if t not in AVAILABLE_TOOLS]
-
-    if do_stream:
+        if role == "tool":
+            role = "user"
+        text = _content_to_str(m.get("content", ""))
+        if text:
+            clean_msgs.append({"role": role, "content": text})
+    
+    all_tools = AVAILABLE_TOOLS + [
+        t for t in client_tools
+        if t.get("name") not in {bt["name"] for bt in AVAILABLE_TOOLS}
+    ]
+    
+    if not do_stream:
+        final_text, tlog = await agentic_loop(clean_msgs, all_tools, model)
+        
+        content_blocks = []
+        for tc in tlog:
+            content_blocks.append({
+                "type": "tool_use",
+                "id": tc["id"],
+                "name": tc["name"],
+                "input": tc["input"]
+            })
+        
+        final_text = re.sub(r'$', '', final_text, flags=re.MULTILINE).strip()
+        if final_text:
+            content_blocks.append({"type": "text", "text": final_text})
+        
+        if not content_blocks:
+            content_blocks.append({"type": "text", "text": final_text})
+        
+        stop_reason = "tool_use" if tlog else "end_turn"
+        
+        return JSONResponse({
+            "id": f"msg_{int(time.time()*1000)}",
+            "type": "message",
+            "role": "assistant",
+            "model": model,
+            "content": content_blocks,
+            "stop_reason": stop_reason,
+            "stop_sequence": None,
+            "usage": {"input_tokens": 0, "output_tokens": len(final_text)}
+        })
+    
+    else:
         async def stream_gen():
-            msg_id = f"msg_{int(time.time())}"
-            yield f"data: {json.dumps({'type':'message_start','message':{'id':msg_id,'type':'message','role':'assistant','model':model,'content':[],'stop_reason':None,'usage':{'input_tokens':0,'output_tokens':0}}})}\n\n"
-            yield f"data: {json.dumps({'type':'content_block_start','index':0,'content_block':{'type':'text','text':''}})}\n\n"
+            msg_id = f"msg_{int(time.time()*1000)}"
+            
+            yield "event: message_start\ndata: " + json.dumps({
+                "type": "message_start",
+                "message": {
+                    "id": msg_id, "type": "message", "role": "assistant",
+                    "model": model, "content": [],
+                    "stop_reason": None, "stop_sequence": None,
+                    "usage": {"input_tokens": 0, "output_tokens": 0}
+                }
+            }) + "\n\n"
+            yield 'event: ping\ndata: {"type":"ping"}\n\n'
+            
+            try:
+                final_text, tlog = await agentic_loop(clean_msgs, all_tools, model)
+            except Exception as e:
+                logger.exception("agentic_loop error")
+                final_text, tlog = f"Error: {e}", []
+            
+            block_idx = 0
+            
+            # tool_use blocks
+            for tc in tlog:
+                tc_json = json.dumps(tc["input"])
+                yield "event: content_block_start\ndata: " + json.dumps({
+                    "type": "content_block_start",
+                    "index": block_idx,
+                    "content_block": {
+                        "type": "tool_use",
+                        "id": tc["id"],
+                        "name": tc["name"],
+                        "input": {}
+                    }
+                }) + "\n\n"
+                yield "event: content_block_delta\ndata: " + json.dumps({
+                    "type": "content_block_delta",
+                    "index": block_idx,
+                    "delta": {"type": "input_json_delta", "partial_json": tc_json}
+                }) + "\n\n"
+                yield "event: content_block_stop\ndata: " + json.dumps({
+                    "type": "content_block_stop", "index": block_idx
+                }) + "\n\n"
+                block_idx += 1
+            
+            # text block
+            final_text = re.sub(r'$', '', final_text, flags=re.MULTILINE).strip()
+            output_text = final_text if final_text else ""
+            
+            if output_text:
+                yield "event: content_block_start\ndata: " + json.dumps({
+                    "type": "content_block_start",
+                    "index": block_idx,
+                    "content_block": {"type": "text", "text": ""}
+                }) + "\n\n"
+                chunk_size = 20
+                for i in range(0, len(output_text), chunk_size):
+                    piece = output_text[i:i+chunk_size]
+                    yield "event: content_block_delta\ndata: " + json.dumps({
+                        "type": "content_block_delta",
+                        "index": block_idx,
+                        "delta": {"type": "text_delta", "text": piece}
+                    }) + "\n\n"
+                    await asyncio.sleep(0)
+                yield "event: content_block_stop\ndata: " + json.dumps({
+                    "type": "content_block_stop", "index": block_idx
+                }) + "\n\n"
+            
+            stop_reason = "tool_use" if tlog else "end_turn"
+            yield "event: message_delta\ndata: " + json.dumps({
+                "type": "message_delta",
+                "delta": {"stop_reason": stop_reason, "stop_sequence": None},
+                "usage": {"output_tokens": len(output_text)}
+            }) + "\n\n"
+            yield 'event: message_stop\ndata: {"type":"message_stop"}\n\n'
+        
+        return StreamingResponse(stream_gen(), media_type="text/event-stream", headers={
+            "Cache-Control": "no-cache", "Connection": "keep-alive", "X-Accel-Buffering": "no"
+        })
 
-            response = agentic_ask(clean_msgs, all_tools)
-            chunk_size = 30
-            for i in range(0, len(response), chunk_size):
-                piece = response[i:i+chunk_size]
-                yield f"data: {json.dumps({'type':'content_block_delta','index':0,'delta':{'type':'text_delta','text':piece}})}\n\n"
+# =====================================================
+# MCP
+# =====================================================
+@app.post("/mcp")
+async def mcp_endpoint(request: Request):
+    _verify(request)
+    body = await request.json()
+    method = body.get("method", "")
+    req_id = body.get("id", 1)
+    
+    if method == "tools/list":
+        return JSONResponse({
+            "jsonrpc": "2.0", "id": req_id,
+            "result": {"tools": [
+                {"name": t["name"], "description": t["description"], "inputSchema": t["input_schema"]}
+                for t in AVAILABLE_TOOLS
+            ]}
+        })
+    
+    elif method == "tools/call":
+        params = body.get("params", {})
+        tname = params.get("name", "")
+        tinput = params.get("arguments", {})
+        loop = asyncio.get_event_loop()
+        result = await loop.run_in_executor(get_executor(), execute_tool, tname, tinput)
+        return JSONResponse({
+            "jsonrpc": "2.0", "id": req_id,
+            "result": {"content": [{"type": "text", "text": result}]}
+        })
+    
+    elif method in ("initialize", "notifications/initialized"):
+        return JSONResponse({
+            "jsonrpc": "2.0", "id": req_id,
+            "result": {
+                "protocolVersion": "2024-11-05",
+                "capabilities": {"tools": {}},
+                "serverInfo": {"name": "g4f-gateway", "version": "1.0.0"}
+            }
+        })
+    
+    return JSONResponse({
+        "jsonrpc": "2.0", "id": req_id,
+        "error": {"code": -32601, "message": f"Method not found: {method}"}
+    })
 
-            yield f"data: {json.dumps({'type':'content_block_stop','index':0})}\n\n"
-            yield f"data: {json.dumps({'type':'message_delta','delta':{'stop_reason':'end_turn','stop_sequence':None},'usage':{'output_tokens':0}})}\n\n"
-            yield f"data: {json.dumps({'type':'message_stop'})}\n\n"
+# =====================================================
+# SIMPLE CHAT
+# =====================================================
+class ChatRequest(BaseModel):
+    message: str
+    provider: str = "Qwen"
+    model: str = "claude-sonnet-4-6"
+    history: List[Any] = []
 
-        return StreamingResponse(stream_gen(), media_type="text/event-stream")
+@app.post("/chat")
+async def chat(request: Request, req: ChatRequest):
+    _verify(request)
+    msgs = [{"role": "user", "content": req.message}]
+    try:
+        text = await g4f_call(msgs, req.model, req.provider)
+    except Exception as e:
+        text = f"Error: {e}"
+    return JSONResponse({"response": text})
 
-    else:
-        response = agentic_ask(clean_msgs, all_tools)
-        return JSONResponse({
-            "id":           f"msg_{int(time.time())}",
-            "type":         "message",
-            "role":         "assistant",
-            "model":        model,
-            "content":      [{"type": "text", "text": response}],
-            "stop_reason":  "end_turn",
-            "stop_sequence": None,
-            "usage":        {"input_tokens": 0, "output_tokens": 0}
-        })
+@app.post("/chat/stream")
+async def chat_stream(request: Request, req: ChatRequest):
+    _verify(request)
+    async def gen():
+        msgs = [{"role": "user", "content": req.message}]
+        try:
+            text = await g4f_stream(msgs, req.model, req.provider)
+        except Exception as e:
+            text = f"Error: {e}"
+        chunk_size = 20
+        for i in range(0, len(text), chunk_size):
+            yield f"data: {json.dumps({'chunk': text[i:i+chunk_size]})}\n\n"
+            await asyncio.sleep(0)
+        yield "data: [DONE]\n\n"
+    return StreamingResponse(gen(), media_type="text/event-stream")
+
+@app.get("/providers")
+async def get_providers(request: Request):
+    _verify(request)
+    return JSONResponse({
+        "providers": {
+            pname: CLAUDE_MODEL_MAP.get(pname, pname) if pname in REAL_PROVIDERS else []
+            for pname in REAL_PROVIDERS
+        }
+    })
 
 if __name__ == "__main__":
     import uvicorn
     port = int(os.getenv("PORT", "7860"))
-    uvicorn.run(app, host="0.0.0.0", port=port)
+    uvicorn.run(app, host="0.0.0.0", port=port, log_level="info")