Update app.py

app.py

@@ -5,6 +5,7 @@ import logging
 import subprocess
 import re
 import asyncio
+import uuid
 from concurrent.futures import ThreadPoolExecutor
 from typing import Any, Dict, List, Optional
 
@@ -13,233 +14,638 @@ from fastapi import FastAPI, HTTPException, Request
 from fastapi.responses import StreamingResponse, JSONResponse
 from pydantic import BaseModel
 
-logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s"
+)
+
 logger = logging.getLogger("g4f-smart-router")
 
+
 # =====================================================
 # THREAD POOL — لتجنب تجميد Event Loop
 # =====================================================
+
 _POOL = ThreadPoolExecutor(max_workers=8)
 
+
 # =====================================================
 # COOKIES
 # =====================================================
+
 def _load_cookies_raw() -> Dict[str, Any]:
     raw_env = (os.getenv("COOKIES_JSON") or "").strip()
+
     if raw_env:
         try:
             return json.loads(raw_env)
         except Exception as e:
             logger.warning(e)
+
     try:
         if os.path.exists("cookies.json"):
             with open("cookies.json", "r", encoding="utf-8") as f:
                 return json.load(f)
+
     except Exception as e:
         logger.warning(e)
+
     return {}
 
+
 def load_cookies() -> str:
     data = _load_cookies_raw()
+
     if not data:
         return "⚠️ No Cookies"
+
     try:
         from g4f.cookies import set_cookies
+
     except Exception:
         return "⚠️ Cookies Found"
+
     for domain, vals in data.items():
         try:
             dom = domain if "." in domain else f".{domain}.com"
+
             if isinstance(vals, list):
-                vals = {x["name"]: x["value"] for x in vals if isinstance(x, dict)}
+                vals = {
+                    x["name"]: x["value"]
+                    for x in vals
+                    if isinstance(x, dict)
+                    and "name" in x
+                    and "value" in x
+                }
+
             if isinstance(vals, dict):
                 set_cookies(dom, vals)
+
         except Exception as e:
             logger.warning(e)
+
     return "✅ Cookies Loaded"
 
+
 COOKIE_STATUS = load_cookies()
 
+
 # =====================================================
 # PROVIDERS (Qwen Only)
 # =====================================================
+
 def get_provider(name: str):
     try:
         return getattr(g4f.Provider, name)
-    except:
+    except Exception:
         return None
 
+
 REAL_PROVIDERS = {
     "Qwen": get_provider("Qwen"),
 }
-REAL_PROVIDERS = {k: v for k, v in REAL_PROVIDERS.items() if v}
+
+REAL_PROVIDERS = {
+    k: v
+    for k, v in REAL_PROVIDERS.items()
+    if v
+}
+
 
 # =====================================================
-# MODELS - تحديث شامل بناء على بحث الانترنت لأسماء Qwen
+# MODELS
 # =====================================================
+
 QWEN_WORKING_MODELS = [
-    "qwen-max",               # الاسم الرسمي لأقوى نسخة
-    "qwen-max-latest",        # تحديثات الداش سكوب
-    "qwen3.7-max",            # تسميات محتملة
+    "qwen-max",
+    "qwen-max-latest",
+    "qwen3.7-max",
     "qwen2.5-max",
-    "qwen2.5-72b-instruct",   # التسمية مفتوحة المصدر الشائعة
+    "qwen2.5-72b-instruct",
     "qwen-plus",
     "qwen-turbo",
-    ""                        # بعض المزودين يستخدم النموذج الافتراضي إذا كان فارغاً
+    "",
 ]
 
+
 PROVIDER_MODELS_FALLBACK: Dict[str, List[str]] = {
     "Qwen": QWEN_WORKING_MODELS,
 }
 
+
 CLAUDE_MODEL_MAP = {
-    "claude-opus-4-6":   "qwen-max",
+    "claude-opus-4-6": "qwen-max",
     "claude-sonnet-4-6": "qwen-max",
-    "claude-haiku-4-5":  "qwen-plus",
+    "claude-haiku-4-5": "qwen-plus",
 }
 
+
 # =====================================================
 # CACHE
 # =====================================================
+
 _CACHE: Dict[str, str] = {}
 _CACHE_TS: Dict[str, float] = {}
 
+
 def cache_get(key):
     ts = _CACHE_TS.get(key)
+
     if ts and (time.time() - ts) < 300:
         return _CACHE.get(key)
+
     return None
 
+
 def cache_set(key, val):
     _CACHE[key] = val
     _CACHE_TS[key] = time.time()
 
+
 # =====================================================
 # STREAM CLEANER
 # =====================================================
+
 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 ""
+                choice = chunk["choices"][0]
+
+                delta = choice.get("delta", {}) or {}
+                message = choice.get("message", {}) or {}
+
+                return (
+                    delta.get("content")
+                    or delta.get("text")
+                    or message.get("content")
+                    or ""
+                )
+
+            return (
+                chunk.get("content")
+                or chunk.get("text")
+                or ""
+            )
+
         if isinstance(chunk, str):
+
             if chunk.strip().startswith("{"):
                 try:
                     d = json.loads(chunk)
+
                     if d.get("code") == "Not_Found":
                         return ""
+
                     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:
+                        choice = d["choices"][0]
+
+                        delta = choice.get("delta", {}) or {}
+                        message = choice.get("message", {}) or {}
+
+                        return (
+                            delta.get("content")
+                            or message.get("content")
+                            or ""
+                        )
+
+                    return (
+                        d.get("content")
+                        or d.get("text")
+                        or ""
+                    )
+
+                except Exception:
                     pass
+
             return chunk.replace("\\n", "\n")
+
         return str(chunk)
-    except Exception as e:
+
+    except Exception:
         return ""
 
+
 # =====================================================
-# CORE ASK (Sync Generator) 
+# CORE ASK (Sync Generator)
 # =====================================================
-def ask(message: str, history: list, provider_name: str, model_name: str):
+
+def ask(
+    message: str,
+    history: list,
+    provider_name: str,
+    model_name: str,
+):
     message = (message or "").strip()
+
     if not message and not history:
         yield ""
         return
 
-    target_model = CLAUDE_MODEL_MAP.get(model_name, model_name)
-    key = f"{provider_name}|{target_model}|{hash(json.dumps(message) + json.dumps(history[-3:] if history else []))}"
+    target_model = CLAUDE_MODEL_MAP.get(
+        model_name,
+        model_name,
+    )
+
+    cache_data = {
+        "provider": provider_name,
+        "model": target_model,
+        "message": message,
+        "history": history[-3:] if history else [],
+    }
+
+    key = json.dumps(
+        cache_data,
+        ensure_ascii=False,
+        sort_keys=True,
+        default=str,
+    )
+
     cached = cache_get(key)
+
     if cached:
         yield cached
         return
 
     msgs = []
+
     if history:
         for item in history[-20:]:
+
             if isinstance(item, dict):
-                r, c = item.get("role"), item.get("content")
-                if r and c and str(c).strip():
-                    msgs.append({"role": str(r), "content": str(c)})
+                role = item.get("role")
+                content = item.get("content")
+
+                if (
+                    role
+                    and content
+                    and str(content).strip()
+                ):
+                    msgs.append({
+                        "role": str(role),
+                        "content": str(content),
+                    })
 
     if message:
-        msgs.append({"role": "user", "content": message})
+        msgs.append({
+            "role": "user",
+            "content": message,
+        })
 
     fallback_order = ["Qwen"]
+
     last_exc = None
 
     for pname in fallback_order:
+
         pobj = REAL_PROVIDERS.get(pname)
+
         if not pobj:
             continue
 
-        candidates = [target_model] + [x for x in QWEN_WORKING_MODELS if x != target_model]
+        candidates = (
+            [target_model]
+            + [
+                x
+                for x in QWEN_WORKING_MODELS
+                if x != target_model
+            ]
+        )
+
+        for model_candidate in candidates:
 
-        for m in candidates:
             try:
                 stream = g4f.ChatCompletion.create(
-                    model=m,
+                    model=model_candidate,
                     provider=pobj,
                     messages=msgs,
                     stream=True,
                 )
+
                 text = ""
+
                 for chunk in stream:
-                    c = _clean_chunk(chunk)
-                    if c:
-                        text += c
+                    cleaned = _clean_chunk(chunk)
+
+                    if cleaned:
+                        text += cleaned
 
                 if text.strip():
                     cache_set(key, text)
+
                     yield text
                     return
+
             except Exception as e:
                 err_str = str(e)
-                # اخفاء أخطاء عدم توفر النموذج في اللوج لتجنب الإزعاج والانتقال للنموذج التالي بسلاسة
-                if "Not_Found" in err_str or "Model not found" in err_str:
+
+                if (
+                    "Not_Found" in err_str
+                    or "Model not found" in err_str
+                ):
                     continue
+
                 last_exc = e
                 continue
 
-    err_msg = f"❌ فشل الاتصال بمزود Qwen نهائياً. الخطأ الأخير: {last_exc}"
+    err_msg = (
+        "❌ فشل الاتصال بمزود Qwen نهائياً. "
+        f"الخطأ الأخير: {last_exc}"
+    )
+
     logger.error(err_msg)
+
     yield err_msg
 
+
 # =====================================================
-# AGENTIC ASK - تم الجراحة هنا (تمرير الأدوات للمستخدم وليس تنفيذها)
+# AGENTIC ASK
 # =====================================================
+
 def _simple_ask_sync(messages: List[Dict]) -> str:
     last_user = ""
     history = []
-    
-    # فصل رسالة المستخدم الأخيرة عن التاريخ
-    for i, m in enumerate(reversed(messages)):
-        if m.get("role") == "user":
-            last_user = m.get("content", "")
-            history = messages[:-i-1] if i != 0 else messages[:-1]
+
+    for i, message in enumerate(reversed(messages)):
+
+        if message.get("role") == "user":
+            last_user = message.get("content", "")
+
+            history = (
+                messages[:-i - 1]
+                if i != 0
+                else messages[:-1]
+            )
+
             break
-    
+
     if not last_user and messages:
         history = messages
         last_user = "Please proceed."
 
     full = ""
-    for chunk in ask(last_user, history, "Qwen", "claude-sonnet-4-6"):
+
+    for chunk in ask(
+        last_user,
+        history,
+        "Qwen",
+        "claude-sonnet-4-6",
+    ):
         full = chunk
 
     return full.strip()
 
-async def ask_llm_async(messages: List[Dict]) -> str:
+
+async def ask_llm_async(
+    messages: List[Dict],
+) -> str:
     loop = asyncio.get_running_loop()
-    return await loop.run_in_executor(_POOL, _simple_ask_sync, messages)
+
+    return await loop.run_in_executor(
+        _POOL,
+        _simple_ask_sync,
+        messages,
+    )
+
+
+# =====================================================
+# TOOL HELPERS
+# =====================================================
+
+def build_tools_prompt(tools: List[Dict]) -> str:
+    """
+    تحويل أدوات OpenAI إلى تعليمات نصية لـ Qwen.
+    """
+
+    if not tools:
+        return ""
+
+    tools_str = json.dumps(
+        tools,
+        ensure_ascii=False,
+    )
+
+    return (
+        "\n\nYou have access to tools.\n"
+        "If you need to use a tool, reply ONLY with:\n"
+        '<tool_call>{"name":"tool_name","input":{"param":"value"}}</tool_call>\n'
+        "Do not use markdown code fences.\n"
+        "Do not explain the tool call.\n"
+        f"Available tools:\n{tools_str}"
+    )
+
+
+def extract_tool_call(
+    response_text: str,
+) -> Optional[Dict[str, Any]]:
+    """
+    استخراج tool_call من رد Qwen.
+    """
+
+    match = re.search(
+        r"<tool_call>\s*(.*?)\s*</tool_call>",
+        response_text,
+        re.DOTALL,
+    )
+
+    if not match:
+        return None
+
+    try:
+        tool_data = json.loads(
+            match.group(1).strip()
+        )
+
+        name = tool_data.get("name")
+
+        arguments = (
+            tool_data.get("input")
+            or tool_data.get("arguments")
+            or {}
+        )
+
+        if not name:
+            return None
+
+        return {
+            "name": str(name),
+            "arguments": arguments,
+            "start": match.start(),
+            "end": match.end(),
+        }
+
+    except Exception as e:
+        logger.error(
+            f"Failed to parse tool JSON: {e}"
+        )
+
+        return None
+
+
+# =====================================================
+# OPENAI HELPERS
+# =====================================================
+
+def openai_error(
+    message: str,
+    error_type: str = "invalid_request_error",
+    code: Optional[str] = None,
+):
+    return {
+        "error": {
+            "message": message,
+            "type": error_type,
+            "param": None,
+            "code": code,
+        }
+    }
+
+
+def normalize_openai_content(content: Any) -> str:
+    """
+    تحويل content بصيغ OpenAI المختلفة إلى نص.
+    """
+
+    if content is None:
+        return ""
+
+    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
+
+            block_type = block.get("type")
+
+            if block_type in (
+                "text",
+                "input_text",
+                "output_text",
+            ):
+                parts.append(
+                    str(
+                        block.get("text")
+                        or block.get("content")
+                        or ""
+                    )
+                )
+
+            elif block_type == "tool_result":
+                parts.append(
+                    "Tool Result "
+                    f"[{block.get('tool_use_id', '')}]: "
+                    f"{block.get('content', '')}"
+                )
+
+            else:
+                text = (
+                    block.get("text")
+                    or block.get("content")
+                )
+
+                if text:
+                    parts.append(str(text))
+
+        return "\n".join(parts)
+
+    return str(content)
+
+
+def normalize_openai_messages(
+    raw_messages: List[Dict],
+) -> List[Dict]:
+    clean_messages = []
+
+    for message in raw_messages:
+
+        if not isinstance(message, dict):
+            continue
+
+        role = str(
+            message.get("role", "user")
+        )
+
+        content = normalize_openai_content(
+            message.get("content", "")
+        )
+
+        if role == "assistant":
+
+            tool_calls = message.get("tool_calls")
+
+            if tool_calls:
+                tool_texts = []
+
+                for tool_call in tool_calls:
+
+                    function_data = (
+                        tool_call.get("function", {})
+                    )
+
+                    tool_texts.append(
+                        "Assistant requested tool "
+                        f"{function_data.get('name', '')} "
+                        f"with arguments "
+                        f"{function_data.get('arguments', '{}')}"
+                    )
+
+                if tool_texts:
+                    content += (
+                        "\n"
+                        + "\n".join(tool_texts)
+                    )
+
+        elif role == "tool":
+
+            tool_call_id = message.get(
+                "tool_call_id",
+                "",
+            )
+
+            content = (
+                f"Tool Result [{tool_call_id}]: "
+                f"{content}"
+            )
+
+            role = "user"
+
+        clean_messages.append({
+            "role": role,
+            "content": content,
+        })
+
+    return clean_messages
+
+
+def approximate_tokens(text: str) -> int:
+    if not text:
+        return 0
+
+    return max(1, len(text) // 4)
+
 
 # =====================================================
 # FASTAPI
 # =====================================================
-app = FastAPI(title="G4F API")
-API_KEY = os.getenv("API_KEY", "mysecretkey123")
+
+app = FastAPI(
+    title="G4F API"
+)
+
+
+API_KEY = os.getenv(
+    "API_KEY",
+    "mysecretkey123",
+)
+
 
 class ChatRequest(BaseModel):
     message: str
@@ -247,142 +653,1174 @@ class ChatRequest(BaseModel):
     model: str = "claude-sonnet-4-6"
     history: List[Any] = []
 
+
 def verify(request: Request):
-    auth = request.headers.get("Authorization", "")
-    if auth.startswith("Bearer ") and auth[7:] == API_KEY:
-        return True
-    if request.headers.get("X-API-Key", "") == API_KEY:
+    """
+    Authentication:
+
+    Authorization: Bearer API_KEY
+
+    ويبقى X-API-Key للتوافق مع الكود السابق.
+    """
+
+    auth = request.headers.get(
+        "Authorization",
+        "",
+    )
+
+    if auth.startswith("Bearer "):
+
+        token = auth[7:].strip()
+
+        if token == API_KEY:
+            return True
+
+    if (
+        request.headers.get("X-API-Key", "")
+        == API_KEY
+    ):
         return True
-    raise HTTPException(status_code=401, detail="Invalid or missing API key")
 
-@app.api_route("/", methods=["GET", "HEAD"])
+    raise HTTPException(
+        status_code=401,
+        detail="Invalid or missing API key",
+    )
+
+
+# =====================================================
+# ROOT
+# =====================================================
+
+@app.api_route(
+    "/",
+    methods=["GET", "HEAD"],
+)
 async def root():
-    return JSONResponse({"status": "✅ running", "model": "Qwen Proxy for Claude"})
+    return JSONResponse({
+        "status": "✅ running",
+        "model": "Qwen Proxy",
+        "openai_base_url": "/v1",
+        "openai_chat_completions": (
+            "/v1/chat/completions"
+        ),
+        "anthropic_messages": "/v1/messages",
+        "cookie_status": COOKIE_STATUS,
+    })
+
+
+# =====================================================
+# OPENAI MODELS
+# =====================================================
 
 @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"])
+    created = int(time.time())
+
+    return JSONResponse({
+        "object": "list",
+        "data": [
+            {
+                "id": "claude-opus-4-6",
+                "object": "model",
+                "created": created,
+                "owned_by": "anthropic",
+            },
+            {
+                "id": "claude-sonnet-4-6",
+                "object": "model",
+                "created": created,
+                "owned_by": "anthropic",
+            },
+            {
+                "id": "claude-haiku-4-5",
+                "object": "model",
+                "created": created,
+                "owned_by": "anthropic",
+            },
+        ],
+    })
+
+
+# =====================================================
+# OPENAI CHAT COMPLETIONS
+# =====================================================
+
+@app.post("/v1/chat/completions")
+async def openai_chat_completions(
+    request: Request,
+):
+    verify(request)
+
+    try:
+        body = await request.json()
+
+    except Exception:
+        return JSONResponse(
+            status_code=400,
+            content=openai_error(
+                "Invalid JSON body"
+            ),
+        )
+
+    model = body.get(
+        "model",
+        "claude-sonnet-4-6",
+    )
+
+    raw_messages = body.get(
+        "messages",
+        [],
+    )
+
+    do_stream = bool(
+        body.get("stream", False)
+    )
+
+    client_tools = (
+        body.get("tools")
+        or []
+    )
+
+    tool_choice = body.get(
+        "tool_choice",
+        "auto",
+    )
+
+    stream_options = (
+        body.get("stream_options")
+        or {}
+    )
+
+    if not isinstance(raw_messages, list):
+        return JSONResponse(
+            status_code=400,
+            content=openai_error(
+                "messages must be an array"
+            ),
+        )
+
+    if not raw_messages:
+        return JSONResponse(
+            status_code=400,
+            content=openai_error(
+                "messages required"
+            ),
+        )
+
+    clean_messages = normalize_openai_messages(
+        raw_messages
+    )
+
+    if client_tools and tool_choice != "none":
+
+        tools_prompt = build_tools_prompt(
+            client_tools
+        )
+
+        if (
+            clean_messages
+            and clean_messages[0].get("role")
+            == "system"
+        ):
+            clean_messages[0]["content"] += (
+                tools_prompt
+            )
+
+        else:
+            clean_messages.insert(
+                0,
+                {
+                    "role": "system",
+                    "content": tools_prompt.strip(),
+                },
+            )
+
+    completion_id = (
+        f"chatcmpl-{uuid.uuid4().hex}"
+    )
+
+    created = int(time.time())
+
+    # =================================================
+    # OPENAI STREAM
+    # =================================================
+
+    if do_stream:
+
+        async def stream_gen():
+
+            try:
+                response_text = await ask_llm_async(
+                    clean_messages
+                )
+
+            except Exception as e:
+                logger.exception(
+                    "OpenAI stream upstream error"
+                )
+
+                error_event = openai_error(
+                    str(e),
+                    "upstream_error",
+                )
+
+                yield (
+                    "data: "
+                    + json.dumps(
+                        error_event,
+                        ensure_ascii=False,
+                    )
+                    + "\n\n"
+                )
+
+                yield "data: [DONE]\n\n"
+
+                return
+
+            tool_data = extract_tool_call(
+                response_text
+            )
+
+            prompt_text = json.dumps(
+                clean_messages,
+                ensure_ascii=False,
+            )
+
+            prompt_tokens = approximate_tokens(
+                prompt_text
+            )
+
+            # -----------------------------------------
+            # TOOL CALL STREAM
+            # -----------------------------------------
+
+            if tool_data:
+
+                pre_text = response_text[
+                    :tool_data["start"]
+                ].strip()
+
+                tool_call_id = (
+                    f"call_{uuid.uuid4().hex[:24]}"
+                )
+
+                if pre_text:
+
+                    first_chunk = {
+                        "id": completion_id,
+                        "object": (
+                            "chat.completion.chunk"
+                        ),
+                        "created": created,
+                        "model": model,
+                        "choices": [
+                            {
+                                "index": 0,
+                                "delta": {
+                                    "role": "assistant",
+                                    "content": "",
+                                },
+                                "finish_reason": None,
+                            }
+                        ],
+                    }
+
+                    yield (
+                        "data: "
+                        + json.dumps(
+                            first_chunk,
+                            ensure_ascii=False,
+                        )
+                        + "\n\n"
+                    )
+
+                    chunk_size = 30
+
+                    for i in range(
+                        0,
+                        len(pre_text),
+                        chunk_size,
+                    ):
+                        piece = pre_text[
+                            i:i + chunk_size
+                        ]
+
+                        chunk = {
+                            "id": completion_id,
+                            "object": (
+                                "chat.completion.chunk"
+                            ),
+                            "created": created,
+                            "model": model,
+                            "choices": [
+                                {
+                                    "index": 0,
+                                    "delta": {
+                                        "content": piece
+                                    },
+                                    "finish_reason": None,
+                                }
+                            ],
+                        }
+
+                        yield (
+                            "data: "
+                            + json.dumps(
+                                chunk,
+                                ensure_ascii=False,
+                            )
+                            + "\n\n"
+                        )
+
+                arguments_json = json.dumps(
+                    tool_data["arguments"],
+                    ensure_ascii=False,
+                    separators=(",", ":"),
+                )
+
+                tool_chunk = {
+                    "id": completion_id,
+                    "object": (
+                        "chat.completion.chunk"
+                    ),
+                    "created": created,
+                    "model": model,
+                    "choices": [
+                        {
+                            "index": 0,
+                            "delta": {
+                                "role": "assistant",
+                                "tool_calls": [
+                                    {
+                                        "index": 0,
+                                        "id": tool_call_id,
+                                        "type": "function",
+                                        "function": {
+                                            "name": tool_data["name"],
+                                            "arguments": arguments_json,
+                                        },
+                                    }
+                                ],
+                            },
+                            "finish_reason": None,
+                        }
+                    ],
+                }
+
+                yield (
+                    "data: "
+                    + json.dumps(
+                        tool_chunk,
+                        ensure_ascii=False,
+                    )
+                    + "\n\n"
+                )
+
+                final_chunk = {
+                    "id": completion_id,
+                    "object": (
+                        "chat.completion.chunk"
+                    ),
+                    "created": created,
+                    "model": model,
+                    "choices": [
+                        {
+                            "index": 0,
+                            "delta": {},
+                            "finish_reason": (
+                                "tool_calls"
+                            ),
+                        }
+                    ],
+                }
+
+                yield (
+                    "data: "
+                    + json.dumps(
+                        final_chunk,
+                        ensure_ascii=False,
+                    )
+                    + "\n\n"
+                )
+
+                if stream_options.get(
+                    "include_usage"
+                ):
+
+                    completion_tokens = (
+                        approximate_tokens(
+                            response_text
+                        )
+                    )
+
+                    usage_chunk = {
+                        "id": completion_id,
+                        "object": (
+                            "chat.completion.chunk"
+                        ),
+                        "created": created,
+                        "model": model,
+                        "choices": [],
+                        "usage": {
+                            "prompt_tokens": (
+                                prompt_tokens
+                            ),
+                            "completion_tokens": (
+                                completion_tokens
+                            ),
+                            "total_tokens": (
+                                prompt_tokens
+                                + completion_tokens
+                            ),
+                        },
+                    }
+
+                    yield (
+                        "data: "
+                        + json.dumps(
+                            usage_chunk,
+                            ensure_ascii=False,
+                        )
+                        + "\n\n"
+                    )
+
+                yield "data: [DONE]\n\n"
+
+                return
+
+            # -----------------------------------------
+            # NORMAL TEXT STREAM
+            # -----------------------------------------
+
+            initial_chunk = {
+                "id": completion_id,
+                "object": "chat.completion.chunk",
+                "created": created,
+                "model": model,
+                "choices": [
+                    {
+                        "index": 0,
+                        "delta": {
+                            "role": "assistant",
+                            "content": "",
+                        },
+                        "finish_reason": None,
+                    }
+                ],
+            }
+
+            yield (
+                "data: "
+                + json.dumps(
+                    initial_chunk,
+                    ensure_ascii=False,
+                )
+                + "\n\n"
+            )
+
+            chunk_size = 30
+
+            for i in range(
+                0,
+                len(response_text),
+                chunk_size,
+            ):
+                piece = response_text[
+                    i:i + chunk_size
+                ]
+
+                chunk = {
+                    "id": completion_id,
+                    "object": (
+                        "chat.completion.chunk"
+                    ),
+                    "created": created,
+                    "model": model,
+                    "choices": [
+                        {
+                            "index": 0,
+                            "delta": {
+                                "content": piece
+                            },
+                            "finish_reason": None,
+                        }
+                    ],
+                }
+
+                yield (
+                    "data: "
+                    + json.dumps(
+                        chunk,
+                        ensure_ascii=False,
+                    )
+                    + "\n\n"
+                )
+
+                await asyncio.sleep(0.005)
+
+            final_chunk = {
+                "id": completion_id,
+                "object": "chat.completion.chunk",
+                "created": created,
+                "model": model,
+                "choices": [
+                    {
+                        "index": 0,
+                        "delta": {},
+                        "finish_reason": "stop",
+                    }
+                ],
+            }
+
+            yield (
+                "data: "
+                + json.dumps(
+                    final_chunk,
+                    ensure_ascii=False,
+                )
+                + "\n\n"
+            )
+
+            if stream_options.get(
+                "include_usage"
+            ):
+
+                completion_tokens = (
+                    approximate_tokens(
+                        response_text
+                    )
+                )
+
+                usage_chunk = {
+                    "id": completion_id,
+                    "object": (
+                        "chat.completion.chunk"
+                    ),
+                    "created": created,
+                    "model": model,
+                    "choices": [],
+                    "usage": {
+                        "prompt_tokens": (
+                            prompt_tokens
+                        ),
+                        "completion_tokens": (
+                            completion_tokens
+                        ),
+                        "total_tokens": (
+                            prompt_tokens
+                            + completion_tokens
+                        ),
+                    },
+                }
+
+                yield (
+                    "data: "
+                    + json.dumps(
+                        usage_chunk,
+                        ensure_ascii=False,
+                    )
+                    + "\n\n"
+                )
+
+            yield "data: [DONE]\n\n"
+
+        return StreamingResponse(
+            stream_gen(),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "X-Accel-Buffering": "no",
+            },
+        )
+
+    # =================================================
+    # OPENAI NON STREAM
+    # =================================================
+
+    try:
+        response_text = await ask_llm_async(
+            clean_messages
+        )
+
+    except Exception as e:
+        logger.exception(
+            "OpenAI upstream error"
+        )
+
+        return JSONResponse(
+            status_code=502,
+            content=openai_error(
+                str(e),
+                "upstream_error",
+            ),
+        )
+
+    tool_data = extract_tool_call(
+        response_text
+    )
+
+    prompt_tokens = approximate_tokens(
+        json.dumps(
+            clean_messages,
+            ensure_ascii=False,
+        )
+    )
+
+    completion_tokens = approximate_tokens(
+        response_text
+    )
+
+    message_data = {
+        "role": "assistant",
+        "content": response_text,
+    }
+
+    finish_reason = "stop"
+
+    if tool_data:
+
+        pre_text = response_text[
+            :tool_data["start"]
+        ].strip()
+
+        tool_call_id = (
+            f"call_{uuid.uuid4().hex[:24]}"
+        )
+
+        message_data = {
+            "role": "assistant",
+            "content": pre_text or None,
+            "tool_calls": [
+                {
+                    "id": tool_call_id,
+                    "type": "function",
+                    "function": {
+                        "name": tool_data["name"],
+                        "arguments": json.dumps(
+                            tool_data["arguments"],
+                            ensure_ascii=False,
+                            separators=(",", ":"),
+                        ),
+                    },
+                }
+            ],
+        }
+
+        finish_reason = "tool_calls"
+
+    return JSONResponse({
+        "id": completion_id,
+        "object": "chat.completion",
+        "created": created,
+        "model": model,
+        "choices": [
+            {
+                "index": 0,
+                "message": message_data,
+                "logprobs": None,
+                "finish_reason": finish_reason,
+            }
+        ],
+        "usage": {
+            "prompt_tokens": prompt_tokens,
+            "completion_tokens": (
+                completion_tokens
+            ),
+            "total_tokens": (
+                prompt_tokens
+                + completion_tokens
+            ),
+        },
+    })
+
+
+# =====================================================
+# ANTHROPIC MESSAGES
+# =====================================================
+
+@app.api_route(
+    "/v1/messages",
+    methods=["POST"],
+)
 async def messages_endpoint(request: 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)
-    client_tools = body.get("tools", [])
-    system_req   = body.get("system", "")
+
+    model = body.get(
+        "model",
+        "claude-sonnet-4-6",
+    )
+
+    raw_messages = body.get(
+        "messages",
+        [],
+    )
+
+    do_stream = body.get(
+        "stream",
+        False,
+    )
+
+    client_tools = body.get(
+        "tools",
+        [],
+    )
+
+    system_req = body.get(
+        "system",
+        "",
+    )
 
     if not raw_messages:
-        raise HTTPException(status_code=400, detail="messages required")
+        raise HTTPException(
+            status_code=400,
+            detail="messages required",
+        )
+
+    system_prompt = (
+        system_req
+        if isinstance(system_req, str)
+        else str(system_req)
+    )
 
-    # إضافة تعليمات الأدوات القادمة من Claude Code إلى Qwen ليقوم بصياغتها بطريقة نستطيع التقاطها
-    system_prompt = system_req if isinstance(system_req, str) else str(system_req)
     if client_tools:
-        tools_str = json.dumps(client_tools, ensure_ascii=False)
-        system_prompt += f"\n\nYou have access to tools. To use one, reply ONLY with this XML format:\n<tool_call>{{\"name\": \"tool_name\", \"input\": {{\"param\": \"value\"}}}}</tool_call>\nAvailable tools: {tools_str}"
+
+        tools_str = json.dumps(
+            client_tools,
+            ensure_ascii=False,
+        )
+
+        system_prompt += (
+            "\n\nYou have access to tools. "
+            "To use one, reply ONLY with "
+            "this XML format:\n"
+            '<tool_call>{"name": "tool_name", '
+            '"input": {"param": "value"}}'
+            "</tool_call>\n"
+            f"Available tools: {tools_str}"
+        )
 
     clean_msgs = []
+
     if system_prompt.strip():
-        clean_msgs.append({"role": "system", "content": system_prompt})
+        clean_msgs.append({
+            "role": "system",
+            "content": system_prompt,
+        })
+
+    for message in raw_messages:
+
+        role = message.get(
+            "role",
+            "user",
+        )
+
+        content = message.get(
+            "content",
+            "",
+        )
 
-    for m in raw_messages:
-        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")
-            # استخراج نتائج الأدوات لو أرسلها Claude Code
-            for b in content:
-                if isinstance(b, dict) and b.get("type") == "tool_result":
-                    text += f"\nTool Result [{b.get('tool_use_id')}]: {b.get('content')}"
+
+            text = " ".join(
+                block.get("text", "")
+                for block in content
+                if isinstance(block, dict)
+                and block.get("type") == "text"
+            )
+
+            for block in content:
+
+                if (
+                    isinstance(block, dict)
+                    and block.get("type")
+                    == "tool_result"
+                ):
+
+                    text += (
+                        "\nTool Result "
+                        f"[{block.get('tool_use_id')}]: "
+                        f"{block.get('content')}"
+                    )
+
         else:
             text = str(content)
-        clean_msgs.append({"role": role, "content": text})
+
+        clean_msgs.append({
+            "role": role,
+            "content": text,
+        })
+
+    # =================================================
+    # ANTHROPIC STREAM
+    # =================================================
 
     if do_stream:
+
         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"
-            
+
+            msg_id = (
+                f"msg_{uuid.uuid4().hex}"
+            )
+
+            yield (
+                "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,
+                        },
+                    },
+                }, ensure_ascii=False)
+                + "\n\n"
+            )
+
             try:
-                response_text = await ask_llm_async(clean_msgs)
+                response_text = (
+                    await ask_llm_async(
+                        clean_msgs
+                    )
+                )
+
             except Exception as e:
                 response_text = f"Error: {e}"
 
-            # البحث عن أمر أداة بداخل نص رد كوين
-            tool_match = re.search(r"<tool_call>(.*?)</tool_call>", response_text, re.DOTALL)
-            
-            if tool_match:
-                # إذا طلب كوين استخدام أداة، نقوم بتجهيزها لـ Claude Code
-                tool_json_str = tool_match.group(1).strip()
-                pre_text = response_text[:tool_match.start()].strip()
-                
-                try:
-                    tool_data = json.loads(tool_json_str)
-                    t_name = tool_data.get("name", "unknown")
-                    t_input = tool_data.get("input", {})
-                    t_id = f"toolu_{int(time.time())}"
-                    
-                    idx = 0
-                    if pre_text:
-                        yield f"data: {json.dumps({'type':'content_block_start','index':idx,'content_block':{'type':'text','text':''}})}\n\n"
-                        chunk_size = 30
-                        for i in range(0, len(pre_text), chunk_size):
-                            piece = pre_text[i:i+chunk_size]
-                            yield f"data: {json.dumps({'type':'content_block_delta','index':idx,'delta':{'type':'text_delta','text':piece}})}\n\n"
-                        yield f"data: {json.dumps({'type':'content_block_stop','index':idx})}\n\n"
-                        idx += 1
-
-                    # إرسال أوامر الأداة لـ Claude Code ليقوم بتنفيذها على جهازك
-                    yield f"data: {json.dumps({'type':'content_block_start','index':idx,'content_block':{'type':'tool_use','id':t_id,'name':t_name,'input':{}}})}\n\n"
-                    yield f"data: {json.dumps({'type':'content_block_delta','index':idx,'delta':{'type':'input_json_delta','partial_json':json.dumps(t_input)}})}\n\n"
-                    yield f"data: {json.dumps({'type':'content_block_stop','index':idx})}\n\n"
-                    
-                    yield f"data: {json.dumps({'type':'message_delta','delta':{'stop_reason':'tool_use','stop_sequence':None},'usage':{'output_tokens':10}})}\n\n"
-                    yield f"data: {json.dumps({'type':'message_stop'})}\n\n"
-                    return
+            tool_data = extract_tool_call(
+                response_text
+            )
 
-                except Exception as e:
-                    logger.error(f"Failed to parse tool JSON: {e}")
-                    pass
+            if tool_data:
+
+                pre_text = response_text[
+                    :tool_data["start"]
+                ].strip()
+
+                tool_id = (
+                    f"toolu_"
+                    f"{uuid.uuid4().hex[:24]}"
+                )
+
+                index = 0
+
+                if pre_text:
+
+                    yield (
+                        "data: "
+                        + json.dumps({
+                            "type": (
+                                "content_block_start"
+                            ),
+                            "index": index,
+                            "content_block": {
+                                "type": "text",
+                                "text": "",
+                            },
+                        }, ensure_ascii=False)
+                        + "\n\n"
+                    )
+
+                    chunk_size = 30
+
+                    for i in range(
+                        0,
+                        len(pre_text),
+                        chunk_size,
+                    ):
+
+                        piece = pre_text[
+                            i:i + chunk_size
+                        ]
+
+                        yield (
+                            "data: "
+                            + json.dumps({
+                                "type": (
+                                    "content_block_delta"
+                                ),
+                                "index": index,
+                                "delta": {
+                                    "type": "text_delta",
+                                    "text": piece,
+                                },
+                            }, ensure_ascii=False)
+                            + "\n\n"
+                        )
+
+                    yield (
+                        "data: "
+                        + json.dumps({
+                            "type": (
+                                "content_block_stop"
+                            ),
+                            "index": index,
+                        })
+                        + "\n\n"
+                    )
+
+                    index += 1
+
+                yield (
+                    "data: "
+                    + json.dumps({
+                        "type": (
+                            "content_block_start"
+                        ),
+                        "index": index,
+                        "content_block": {
+                            "type": "tool_use",
+                            "id": tool_id,
+                            "name": tool_data["name"],
+                            "input": {},
+                        },
+                    }, ensure_ascii=False)
+                    + "\n\n"
+                )
+
+                yield (
+                    "data: "
+                    + json.dumps({
+                        "type": (
+                            "content_block_delta"
+                        ),
+                        "index": index,
+                        "delta": {
+                            "type": (
+                                "input_json_delta"
+                            ),
+                            "partial_json": (
+                                json.dumps(
+                                    tool_data[
+                                        "arguments"
+                                    ],
+                                    ensure_ascii=False,
+                                )
+                            ),
+                        },
+                    }, ensure_ascii=False)
+                    + "\n\n"
+                )
+
+                yield (
+                    "data: "
+                    + json.dumps({
+                        "type": (
+                            "content_block_stop"
+                        ),
+                        "index": index,
+                    })
+                    + "\n\n"
+                )
+
+                yield (
+                    "data: "
+                    + json.dumps({
+                        "type": "message_delta",
+                        "delta": {
+                            "stop_reason": "tool_use",
+                            "stop_sequence": None,
+                        },
+                        "usage": {
+                            "output_tokens": (
+                                approximate_tokens(
+                                    response_text
+                                )
+                            ),
+                        },
+                    }, ensure_ascii=False)
+                    + "\n\n"
+                )
+
+                yield (
+                    "data: "
+                    + json.dumps({
+                        "type": "message_stop"
+                    })
+                    + "\n\n"
+                )
+
+                return
+
+            yield (
+                "data: "
+                + json.dumps({
+                    "type": "content_block_start",
+                    "index": 0,
+                    "content_block": {
+                        "type": "text",
+                        "text": "",
+                    },
+                }, ensure_ascii=False)
+                + "\n\n"
+            )
 
-            # الرد العادي بدون أدوات
-            yield f"data: {json.dumps({'type':'content_block_start','index':0,'content_block':{'type':'text','text':''}})}\n\n"
             chunk_size = 30
-            for i in range(0, len(response_text), chunk_size):
-                piece = response_text[i:i+chunk_size]
-                yield f"data: {json.dumps({'type':'content_block_delta','index':0,'delta':{'type':'text_delta','text':piece}})}\n\n"
+
+            for i in range(
+                0,
+                len(response_text),
+                chunk_size,
+            ):
+
+                piece = response_text[
+                    i:i + chunk_size
+                ]
+
+                yield (
+                    "data: "
+                    + json.dumps({
+                        "type": "content_block_delta",
+                        "index": 0,
+                        "delta": {
+                            "type": "text_delta",
+                            "text": piece,
+                        },
+                    }, ensure_ascii=False)
+                    + "\n\n"
+                )
+
                 await asyncio.sleep(0.005)
 
-            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':len(response_text)//4}})}\n\n"
-            yield f"data: {json.dumps({'type':'message_stop'})}\n\n"
+            yield (
+                "data: "
+                + json.dumps({
+                    "type": "content_block_stop",
+                    "index": 0,
+                })
+                + "\n\n"
+            )
+
+            yield (
+                "data: "
+                + json.dumps({
+                    "type": "message_delta",
+                    "delta": {
+                        "stop_reason": "end_turn",
+                        "stop_sequence": None,
+                    },
+                    "usage": {
+                        "output_tokens": (
+                            approximate_tokens(
+                                response_text
+                            )
+                        ),
+                    },
+                }, ensure_ascii=False)
+                + "\n\n"
+            )
+
+            yield (
+                "data: "
+                + json.dumps({
+                    "type": "message_stop"
+                })
+                + "\n\n"
+            )
 
         return StreamingResponse(
             stream_gen(),
             media_type="text/event-stream",
-            headers={"Cache-Control": "no-cache", "Connection": "keep-alive"}
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "X-Accel-Buffering": "no",
+            },
         )
+
+    # =================================================
+    # ANTHROPIC NON STREAM
+    # =================================================
+
+    response_text = await ask_llm_async(
+        clean_msgs
+    )
+
+    tool_data = extract_tool_call(
+        response_text
+    )
+
+    content_blocks = []
+
+    stop_reason = "end_turn"
+
+    if tool_data:
+
+        pre_text = response_text[
+            :tool_data["start"]
+        ].strip()
+
+        if pre_text:
+            content_blocks.append({
+                "type": "text",
+                "text": pre_text,
+            })
+
+        content_blocks.append({
+            "type": "tool_use",
+            "id": (
+                f"toolu_{uuid.uuid4().hex[:24]}"
+            ),
+            "name": tool_data["name"],
+            "input": tool_data["arguments"],
+        })
+
+        stop_reason = "tool_use"
+
     else:
-        # مسار Non-stream مشابه يمكن تركه كـ fallback
-        response_text = await ask_llm_async(clean_msgs)
-        return JSONResponse({
-            "id": f"msg_{int(time.time())}",
-            "type": "message",
-            "role": "assistant",
-            "model": model,
-            "content": [{"type": "text", "text": response_text}],
-            "stop_reason": "end_turn",
-            "usage": {"input_tokens": 0, "output_tokens": len(response_text)//4}
+        content_blocks.append({
+            "type": "text",
+            "text": response_text,
         })
 
+    return JSONResponse({
+        "id": f"msg_{uuid.uuid4().hex}",
+        "type": "message",
+        "role": "assistant",
+        "model": model,
+        "content": content_blocks,
+        "stop_reason": stop_reason,
+        "stop_sequence": None,
+        "usage": {
+            "input_tokens": approximate_tokens(
+                json.dumps(
+                    clean_msgs,
+                    ensure_ascii=False,
+                )
+            ),
+            "output_tokens": approximate_tokens(
+                response_text
+            ),
+        },
+    })
+
+
+# =====================================================
+# ENTRY POINT
+# =====================================================
+
 if __name__ == "__main__":
     import uvicorn
-    port = int(os.getenv("PORT", "7860"))
-    uvicorn.run(app, host="0.0.0.0", port=port)
+
+    port = int(
+        os.getenv(
+            "PORT",
+            "7860",
+        )
+    )
+
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=port,
+    )