Update app.py

app.py

@@ -8,6 +8,7 @@ from typing import Any, Dict, List, Optional
 from collections import OrderedDict
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.responses import StreamingResponse, JSONResponse, Response
+from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 import g4f
 
@@ -103,10 +104,10 @@ CACHE = TTLCache(max_size=100, ttl_seconds=300)
 def get_provider(name: str):
     try:
         return getattr(g4f.Provider, name)
-    except:
+    except Exception:
         return None
 
-# ترتيب المزودات حسب احتمال النجاح (جربناها)
+# ترتيب المزودات حسب احتمال النجاح
 REAL_PROVIDERS = {
     "Blackbox": get_provider("Blackbox"),
     "DeepSeek": get_provider("DeepSeek"),
@@ -119,7 +120,7 @@ REAL_PROVIDERS = {
 REAL_PROVIDERS = {k: v for k, v in REAL_PROVIDERS.items() if v}
 
 # =====================================================
-# MODELS - قائمة نماذج لكل مزود (مصادر موثوقة)
+# MODELS - قائمة نماذج لكل مزود
 # =====================================================
 PROVIDER_MODELS_FALLBACK = {
     "Blackbox": ["gpt-4o", "claude-3.5-sonnet", "llama-3.1-70b", "gemini-pro"],
@@ -137,12 +138,10 @@ PROVIDER_MODELS_FALLBACK = {
 _PROVIDER_MODEL_CACHE = {}
 
 def discover_provider_models(provider_obj: Any, provider_name: str) -> List[str]:
-    # إذا كان هناك cache استخدمه
     if provider_name in _PROVIDER_MODEL_CACHE:
         return _PROVIDER_MODEL_CACHE[provider_name]
-    
+
     candidates = []
-    # حاول اكتشاف النماذج من الكائن
     for attr in ("models", "model", "default_model", "available_models", "supported_models"):
         try:
             if hasattr(provider_obj, attr):
@@ -153,13 +152,12 @@ def discover_provider_models(provider_obj: Any, provider_name: str) -> List[str]
                     candidates.extend(str(i) for i in val)
                 elif val:
                     candidates.append(str(val))
-        except:
+        except Exception:
             pass
-    # إذا لم يكتشف شيئاً استخدم fallback
+
     if not candidates:
         candidates = PROVIDER_MODELS_FALLBACK.get(provider_name, ["gpt-4o"])
-    
-    # إزالة التكرار
+
     seen = set()
     unique = [m for m in candidates if not (m in seen or seen.add(m))]
     _PROVIDER_MODEL_CACHE[provider_name] = unique
@@ -187,7 +185,7 @@ def clean_stream(chunk):
                         if 'content' in delta:
                             return delta['content']
                     return data.get('content') or data.get('text') or ""
-                except:
+                except Exception:
                     pass
             if '\\' in chunk:
                 chunk = chunk.replace('\\n', '\n')
@@ -201,6 +199,30 @@ def clean_stream(chunk):
         logger.warning(f"clean_stream error: {e}")
         return ""
 
+# =====================================================
+# استخراج النص من content (يدعم string و list)
+# إصلاح: Claude يرسل content كـ list من الكائنات
+# =====================================================
+def extract_text_from_content(content) -> str:
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts = []
+        for item in content:
+            if isinstance(item, str):
+                parts.append(item)
+            elif isinstance(item, dict):
+                if item.get("type") == "text":
+                    parts.append(item.get("text", ""))
+                elif "text" in item:
+                    parts.append(item["text"])
+                elif "content" in item:
+                    parts.append(str(item["content"]))
+        return "\n".join(parts)
+    if content is not None:
+        return str(content)
+    return ""
+
 # =====================================================
 # CHAT LOGIC - مع fallback ذكي
 # =====================================================
@@ -221,25 +243,27 @@ def ask(message: str, history, provider_name: str, model_name: str, stop_flag=No
     msgs = []
     try:
         if history:
-            if history and isinstance(history[0], dict):
+            if isinstance(history[0], dict):
                 for item in history[-40:]:
-                    if role := item.get("role"):
-                        if content := item.get("content"):
-                            msgs.append({"role": str(role), "content": str(content)})
+                    role = item.get("role")
+                    content = item.get("content")
+                    if role and content:
+                        text = extract_text_from_content(content)
+                        if text:
+                            msgs.append({"role": str(role), "content": text})
             else:
                 for item in history[-20:]:
                     if isinstance(item, (list, tuple)) and len(item) == 2:
-                        if u := item[0]:
-                            msgs.append({"role": "user", "content": str(u)})
-                        if a := item[1]:
-                            msgs.append({"role": "assistant", "content": str(a)})
+                        if item[0]:
+                            msgs.append({"role": "user", "content": str(item[0])})
+                        if item[1]:
+                            msgs.append({"role": "assistant", "content": str(item[1])})
     except Exception as e:
         logger.warning(f"History error: {e}")
 
     msgs.append({"role": "user", "content": message})
 
-    # قائمة المزودات التي سنحاولها (مرتبة حسب احتمال النجاح)
-    # المزود المطلوب أولاً ثم Blackbox ثم DeepSeek ثم البقية
+    # قائمة المزودات التي سنحاولها
     fallback_providers = [
         provider_name,
         "Blackbox",
@@ -261,19 +285,17 @@ def ask(message: str, history, provider_name: str, model_name: str, stop_flag=No
             logger.info(f"Provider {pname} not available, skipping")
             continue
 
-        # الحصول على قائمة النماذج لهذا المزود
         models_list = discover_provider_models(pobj, pname)
         if not models_list:
             logger.warning(f"No models for provider {pname}")
             continue
 
-        # ترتيب النماذج: النموذج المطلوب أولاً ثم بقية النماذج
         if model_name in models_list:
             model_candidates = [model_name] + [m for m in models_list if m != model_name]
         else:
             model_candidates = models_list
 
-        for m in model_candidates[:10]:  # جرب أول 10 نماذج كحد أقصى
+        for m in model_candidates[:10]:
             try:
                 logger.info(f"Trying provider {pname} with model {m}")
                 stream = g4f.ChatCompletion.create(
@@ -307,6 +329,15 @@ def ask(message: str, history, provider_name: str, model_name: str, stop_flag=No
 # =====================================================
 app = FastAPI(title="G4F Smart Router", description="AI Gateway - متعدد المزودات")
 
+# إضافة CORS للسماح بالطلبات من أي مصدر
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
 API_KEY = os.getenv("API_KEY", "mysecretkey123")
 
 class ChatRequest(BaseModel):
@@ -332,7 +363,10 @@ def verify_api_key(request: Request):
     if x_api_key and x_api_key == API_KEY:
         return True
 
-    raise HTTPException(status_code=401, detail="Invalid API key. Use 'Authorization: Bearer KEY' or 'X-API-Key: KEY'")
+    raise HTTPException(
+        status_code=401,
+        detail="Invalid API key. Use 'Authorization: Bearer KEY' or 'X-API-Key: KEY'"
+    )
 
 # =====================================================
 # دعم HEAD (لإصلاح 405)
@@ -349,88 +383,325 @@ async def head_health():
 async def head_models():
     return Response(status_code=200)
 
+@app.head("/v1/messages")
+async def head_messages():
+    return Response(status_code=200)
+
+@app.head("/v1/chat/completions")
+async def head_chat_completions():
+    return Response(status_code=200)
+
 # =====================================================
-# نقاط نهاية متوافقة مع Claude Desktop
+# نقاط نهاية متوافقة مع Claude Coowork و Anthropic API
 # =====================================================
 @app.get("/v1/models")
 async def v1_models(request: Request):
-    # لا تحتاج مفتاح لهذه النقطة (Claude Desktop يطلبها أولاً)
     models = []
+    seen_ids = set()
     for pname, pobj in REAL_PROVIDERS.items():
         models_list = discover_provider_models(pobj, pname)
-        for model in models_list[:5]:  # نعرض أول 5 نماذج لكل مزود
-            models.append({
-                "id": model,
-                "type": "model",
-                "display_name": f"{pname} - {model}"
-            })
+        for model in models_list[:5]:
+            if model not in seen_ids:
+                seen_ids.add(model)
+                models.append({
+                    "id": model,
+                    "object": "model",
+                    "created": int(time.time()),
+                    "owned_by": pname,
+                    "type": "model",
+                    "display_name": f"{pname} - {model}"
+                })
     if not models:
-        models = [{"id": "gpt-4o", "type": "model", "display_name": "Default"}]
-    return {"data": models}
+        models = [{
+            "id": "gpt-4o",
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "system",
+            "type": "model",
+            "display_name": "Default"
+        }]
+    return {"object": "list", "data": models}
 
+# =====================================================
+# إصلاح: نقطة /v1/messages تدعم stream و non-stream
+# Claude Coowork يرسل stream: true في body نفسه
+# =====================================================
 @app.post("/v1/messages")
 async def v1_messages(request: Request):
     verify_api_key(request)
     body = await request.json()
+
     messages = body.get("messages", [])
     if not messages:
         raise HTTPException(status_code=400, detail="No messages provided")
-    last_message = messages[-1]
-    user_message = last_message.get("content", "")
+
+    # استخراج النموذج
     model = body.get("model", "gpt-4o")
     system_prompt = body.get("system", "")
+    is_stream = body.get("stream", False)
+    max_tokens = body.get("max_tokens", 4096)
+
+    # استخراج آخر رسالة مستخدم
+    last_message = messages[-1]
+    user_message = extract_text_from_content(last_message.get("content", ""))
+
+    # بناء history من كل الرسائل ما عدا الأخيرة
     history = []
     for msg in messages[:-1]:
         role = msg.get("role", "user")
-        content = msg.get("content", "")
-        history.append({"role": role, "content": content})
+        content = extract_text_from_content(msg.get("content", ""))
+        if role and content:
+            history.append({"role": role, "content": content})
+
+    # إضافة system prompt إذا وجد
     full_message = user_message
     if system_prompt:
         full_message = f"[System: {system_prompt}]\n\n{user_message}"
-    
+
+    # إذا كان stream مطلوب
+    if is_stream:
+        return await _handle_anthropic_stream(full_message, history, model, max_tokens)
+
+    # وضع non-stream: تجميع الرد كاملاً
     full_response = ""
     for chunk in ask(full_message, history, "Blackbox", model):
-        full_response = chunk
-    
+        full_response += chunk  # إصلاح: += بدلاً من =
+
+    message_id = f"msg_{int(time.time())}_{os.urandom(4).hex()}"
+    input_tokens = max(1, len(user_message) // 4)
+    output_tokens = max(1, len(full_response) // 4)
+
     return {
-        "id": f"msg_{int(time.time())}_{os.urandom(4).hex()}",
+        "id": message_id,
         "type": "message",
         "role": "assistant",
         "content": [{"type": "text", "text": full_response}],
         "model": model,
         "stop_reason": "end_turn",
         "stop_sequence": None,
-        "usage": {"input_tokens": len(user_message)//4, "output_tokens": len(full_response)//4}
+        "usage": {
+            "input_tokens": input_tokens,
+            "output_tokens": output_tokens
+        }
     }
 
+# =====================================================
+# معالج الـ streaming بصيغة Anthropic SSE
+# =====================================================
+async def _handle_anthropic_stream(full_message: str, history: list, model: str, max_tokens: int):
+    async def generate_stream():
+        message_id = f"msg_{int(time.time())}_{os.urandom(4).hex()}"
+
+        # حدث بداية الرسالة
+        msg_start = {
+            "type": "message_start",
+            "message": {
+                "id": message_id,
+                "type": "message",
+                "role": "assistant",
+                "content": [],
+                "model": model,
+                "stop_reason": None,
+                "stop_sequence": None,
+                "usage": {
+                    "input_tokens": max(1, len(full_message) // 4),
+                    "output_tokens": 0
+                }
+            }
+        }
+        yield f"event: message_start\ndata: {json.dumps(msg_start, ensure_ascii=False)}\n\n"
+
+        # حدث بداية كتلة المحتوى
+        block_start = {
+            "type": "content_block_start",
+            "index": 0,
+            "content_block": {
+                "type": "text",
+                "text": ""
+            }
+        }
+        yield f"event: content_block_start\ndata: {json.dumps(block_start, ensure_ascii=False)}\n\n"
+
+        # إرسال أجزاء النص
+        output_tokens = 0
+        for chunk in ask(full_message, history, "Blackbox", model):
+            if chunk:
+                output_tokens += max(1, len(chunk) // 4)
+                delta_event = {
+                    "type": "content_block_delta",
+                    "index": 0,
+                    "delta": {
+                        "type": "text_delta",
+                        "text": chunk
+                    }
+                }
+                yield f"event: content_block_delta\ndata: {json.dumps(delta_event, ensure_ascii=False)}\n\n"
+
+        # حدث نهاية كتلة المحتوى
+        block_stop = {
+            "type": "content_block_stop",
+            "index": 0
+        }
+        yield f"event: content_block_stop\ndata: {json.dumps(block_stop, ensure_ascii=False)}\n\n"
+
+        # حدث دلتا الرسالة (نهاية)
+        msg_delta = {
+            "type": "message_delta",
+            "delta": {
+                "stop_reason": "end_turn",
+                "stop_sequence": None
+            },
+            "usage": {
+                "output_tokens": output_tokens
+            }
+        }
+        yield f"event: message_delta\ndata: {json.dumps(msg_delta, ensure_ascii=False)}\n\n"
+
+        # حدث توقف الرسالة
+        yield f"event: message_stop\ndata: {{\"type\": \"message_stop\"}}\n\n"
+
+    return StreamingResponse(
+        generate_stream(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",
+        }
+    )
+
+# =====================================================
+# إصلاح: نقطة /v1/messages/stream منفصلة (للتوافق)
+# =====================================================
 @app.post("/v1/messages/stream")
 async def v1_messages_stream(request: Request):
     verify_api_key(request)
     body = await request.json()
+
     messages = body.get("messages", [])
     if not messages:
         raise HTTPException(status_code=400, detail="No messages provided")
+
     last_message = messages[-1]
-    user_message = last_message.get("content", "")
+    user_message = extract_text_from_content(last_message.get("content", ""))
     model = body.get("model", "gpt-4o")
     system_prompt = body.get("system", "")
+    max_tokens = body.get("max_tokens", 4096)
+
+    # بناء history
+    history = []
+    for msg in messages[:-1]:
+        role = msg.get("role", "user")
+        content = extract_text_from_content(msg.get("content", ""))
+        if role and content:
+            history.append({"role": role, "content": content})
+
     full_message = user_message
     if system_prompt:
         full_message = f"[System: {system_prompt}]\n\n{user_message}"
-    
-    async def generate_stream():
-        message_id = f"msg_{int(time.time())}_{os.urandom(4).hex()}"
-        yield f"event: message_start\ndata: {{\"message\": {{\"id\": \"{message_id}\", \"type\": \"message\", \"role\": \"assistant\", \"content\": [], \"model\": \"{model}\", \"stop_reason\": null, \"stop_sequence\": null, \"usage\": {{\"input_tokens\": 0, \"output_tokens\": 0}}}}}}\n\n"
-        yield f"event: content_block_start\ndata: {{\"type\": \"content_block_start\", \"index\": 0, \"content_block\": {{\"type\": \"text\", \"text\": \"\"}}}}\n\n"
-        for chunk in ask(full_message, [], "Blackbox", model):
-            yield f"event: content_block_delta\ndata: {{\"type\": \"content_block_delta\", \"index\": 0, \"delta\": {{\"type\": \"text_delta\", \"text\": {json.dumps(chunk, ensure_ascii=False)}}}}}\n\n"
-        yield f"event: message_delta\ndata: {{\"type\": \"message_delta\", \"delta\": {{\"stop_reason\": \"end_turn\", \"stop_sequence\": null}}, \"usage\": {{\"output_tokens\": 100}}}}\n\n"
-        yield f"event: message_stop\ndata: {{}}\n\n"
-    
-    return StreamingResponse(generate_stream(), media_type="text/event-stream", headers={"Cache-Control": "no-cache", "Connection": "keep-alive"})
+
+    return await _handle_anthropic_stream(full_message, history, model, max_tokens)
+
+# =====================================================
+# إضافة: نقطة /v1/chat/completions (صيغة OpenAI)
+# بعض العملاء يستخدمون هذه الصيغة
+# =====================================================
+@app.post("/v1/chat/completions")
+async def v1_chat_completions(request: Request):
+    verify_api_key(request)
+    body = await request.json()
+
+    messages = body.get("messages", [])
+    if not messages:
+        raise HTTPException(status_code=400, detail="No messages provided")
+
+    model = body.get("model", "gpt-4o")
+    is_stream = body.get("stream", False)
+
+    # استخراج آخر رسالة
+    last_message = messages[-1]
+    user_message = extract_text_from_content(last_message.get("content", ""))
+
+    # بناء history
+    history = []
+    for msg in messages[:-1]:
+        role = msg.get("role", "user")
+        content = extract_text_from_content(msg.get("content", ""))
+        if role and content:
+            history.append({"role": role, "content": content})
+
+    completion_id = f"chatcmpl-{int(time.time())}_{os.urandom(4).hex()}"
+
+    if is_stream:
+        # OpenAI streaming format
+        async def openai_stream():
+            for chunk in ask(user_message, history, "Blackbox", model):
+                if chunk:
+                    data = {
+                        "id": completion_id,
+                        "object": "chat.completion.chunk",
+                        "created": int(time.time()),
+                        "model": model,
+                        "choices": [{
+                            "index": 0,
+                            "delta": {"content": chunk},
+                            "finish_reason": None
+                        }]
+                    }
+                    yield f"data: {json.dumps(data, ensure_ascii=False)}\n\n"
+
+            # إرسال حدث النهاية
+            final_data = {
+                "id": completion_id,
+                "object": "chat.completion.chunk",
+                "created": int(time.time()),
+                "model": model,
+                "choices": [{
+                    "index": 0,
+                    "delta": {},
+                    "finish_reason": "stop"
+                }]
+            }
+            yield f"data: {json.dumps(final_data, ensure_ascii=False)}\n\n"
+            yield "data: [DONE]\n\n"
+
+        return StreamingResponse(
+            openai_stream(),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "X-Accel-Buffering": "no",
+            }
+        )
+
+    # Non-stream OpenAI format
+    full_response = ""
+    for chunk in ask(user_message, history, "Blackbox", model):
+        full_response += chunk
+
+    return {
+        "id": completion_id,
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": model,
+        "choices": [{
+            "index": 0,
+            "message": {
+                "role": "assistant",
+                "content": full_response
+            },
+            "finish_reason": "stop"
+        }],
+        "usage": {
+            "prompt_tokens": max(1, len(user_message) // 4),
+            "completion_tokens": max(1, len(full_response) // 4),
+            "total_tokens": max(1, (len(user_message) + len(full_response)) // 4)
+        }
+    }
 
 # =====================================================
-# نقاط نهاية إضافية للتوافق القديم
+# نقاط نهاية إضافية
 # =====================================================
 @app.get("/")
 async def root():
@@ -439,10 +710,13 @@ async def root():
         "providers": list(REAL_PROVIDERS.keys()),
         "endpoints": {
             "GET /": "Home",
-            "GET /health": "Health",
+            "GET /health": "Health check",
             "GET /v1/models": "List models (NO AUTH)",
-            "POST /v1/messages": "Send message (AUTH)",
-            "POST /v1/messages/stream": "Stream (AUTH)",
+            "POST /v1/messages": "Anthropic format - Send message (AUTH, supports stream:true)",
+            "POST /v1/messages/stream": "Anthropic format - Stream only (AUTH)",
+            "POST /v1/chat/completions": "OpenAI format - Send message (AUTH, supports stream:true)",
+            "POST /chat": "Simple chat (AUTH)",
+            "POST /chat/stream": "Simple stream (AUTH)",
             "GET /providers": "Providers list (AUTH)",
         },
         "cookies": COOKIE_STATUS,
@@ -451,29 +725,79 @@ async def root():
 
 @app.get("/health")
 async def health():
-    return {"status": "ok", "cookies": COOKIE_STATUS, "providers": list(REAL_PROVIDERS.keys())}
+    return {
+        "status": "ok",
+        "cookies": COOKIE_STATUS,
+        "providers": list(REAL_PROVIDERS.keys()),
+        "provider_count": len(REAL_PROVIDERS),
+        "timestamp": int(time.time())
+    }
 
 @app.get("/providers")
 async def get_providers(request: Request):
     verify_api_key(request)
-    return {"providers": list(REAL_PROVIDERS.keys())}
+    result = {}
+    for pname, pobj in REAL_PROVIDERS.items():
+        models = discover_provider_models(pobj, pname)
+        result[pname] = {
+            "available": True,
+            "models": models
+        }
+    return {"providers": result}
 
 @app.post("/chat")
 async def chat(request: Request, chat_req: ChatRequest):
     verify_api_key(request)
     result = ""
     for chunk in ask(chat_req.message, chat_req.history, chat_req.provider, chat_req.model):
-        result = chunk
+        result += chunk  # إصلاح: += بدلاً من =
     return JSONResponse({"response": result})
 
 @app.post("/chat/stream")
 async def chat_stream(request: Request, chat_req: ChatRequest):
     verify_api_key(request)
+
     async def generate():
         for chunk in ask(chat_req.message, chat_req.history, chat_req.provider, chat_req.model):
             yield f"data: {json.dumps({'delta': chunk}, ensure_ascii=False)}\n\n"
         yield "data: [DONE]\n\n"
-    return StreamingResponse(generate(), media_type="text/event-stream")
+
+    return StreamingResponse(
+        generate(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+        }
+    )
+
+# =====================================================
+# معالجة الأخطاء العامة
+# =====================================================
+@app.exception_handler(404)
+async def not_found_handler(request: Request, exc: HTTPException):
+    return JSONResponse(
+        status_code=404,
+        content={
+            "error": {
+                "type": "not_found_error",
+                "message": f"Endpoint {request.method} {request.url.path} not found"
+            }
+        }
+    )
+
+@app.exception_handler(500)
+async def internal_error_handler(request: Request, exc: Exception):
+    logger.error(f"Internal error: {str(exc)}")
+    return JSONResponse(
+        status_code=500,
+        content={
+            "error": {
+                "type": "api_error",
+                "message": "Internal server error"
+            }
+        }
+    )
 
 # =====================================================
 # التشغيل
@@ -481,4 +805,7 @@ async def chat_stream(request: Request, chat_req: ChatRequest):
 if __name__ == "__main__":
     import uvicorn
     port = int(os.getenv("PORT", 7860))
-    uvicorn.run("app:app", host="0.0.0.0", port=port, reload=False)
+    logger.info(f"Starting G4F Smart Router on port {port}")
+    logger.info(f"Cookies: {COOKIE_STATUS}")
+    logger.info(f"Available providers: {list(REAL_PROVIDERS.keys())}")
+    uvicorn.run("app:app", host="0.0.0.0", port=port, reload=False)