Update app.py

app.py

@@ -83,11 +83,9 @@ def verify_api_key(req: Request):
 
     token = None
 
-    # دعم x-api-key
     if x_api_key:
         token = x_api_key.strip()
 
-    # دعم Authorization Bearer
     elif auth:
 
         parts = auth.split(" ", 1)
@@ -95,11 +93,9 @@ def verify_api_key(req: Request):
         if len(parts) == 2:
             token = parts[1].strip()
 
-    # لو لم يتم استخراج توكن صالح
     if not token:
         return True
 
-    # تحقق اختياري فقط
     if API_KEY and token != API_KEY:
         raise HTTPException(
             status_code=403,
@@ -125,7 +121,69 @@ async def root():
 
 @app.head("/")
 async def root_head():
-    return JSONResponse(status_code=200, content={})
+    return JSONResponse(
+        status_code=200,
+        content={}
+    )
+
+
+# =====================================================
+# MODEL NORMALIZER
+# =====================================================
+
+def normalize_model(model: str):
+
+    if not model:
+        return "gpt-4o-mini"
+
+    model_lower = model.lower()
+
+    # GPT
+    if "gpt-4" in model_lower:
+        return "gpt-4"
+
+    if "gpt-3.5" in model_lower:
+        return "gpt-3.5-turbo"
+
+    # Claude
+    if "claude" in model_lower:
+        return "gpt-4"
+
+    # Gemini
+    if "gemini" in model_lower:
+        return "gemini"
+
+    # Cohere / Command
+    if "command-r-plus" in model_lower:
+        return "command-r-plus"
+
+    if "command-r" in model_lower:
+        return "command-r"
+
+    # Grok
+    if "grok" in model_lower:
+        return "gpt-4"
+
+    # Llama
+    if "llama" in model_lower:
+        return "llama-3-70b"
+
+    # Mistral
+    if "mistral" in model_lower:
+        return "mistral-7b"
+
+    return model
+
+
+# =====================================================
+# SAFE CLIENT
+# =====================================================
+
+def create_client():
+
+    return Client(
+        provider=g4f.Provider.Blackbox
+    )
 
 
 # =====================================================
@@ -137,24 +195,37 @@ async def get_models():
 
     models_data = []
 
-    try:
+    visible_models = [
 
-        if hasattr(g4f.models, "_all_models"):
+        "gpt-4",
+        "gpt-4-turbo",
+        "gpt-4o",
+        "gpt-4o-mini",
+        "gpt-3.5-turbo",
 
-            all_models = list(g4f.models._all_models)
+        "claude-sonnet-4-6",
+        "claude-opus-4",
+        "claude-3-7-sonnet",
 
-            for model in all_models:
+        "gemini-2.5-pro",
+        "gemini-2.5-flash",
 
-                models_data.append({
-                    "id": str(model),
-                    "object": "model",
-                    "created": int(time.time()),
-                    "owned_by": "g4f"
-                })
+        "command-r",
+        "command-r-plus",
 
-    except Exception as e:
+        "grok-4",
+        "llama-3-70b",
+        "mistral-7b"
+    ]
 
-        logger.error(f"Models error: {e}")
+    for model in visible_models:
+
+        models_data.append({
+            "id": model,
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "g4f"
+        })
 
     return {
         "object": "list",
@@ -162,46 +233,6 @@ async def get_models():
     }
 
 
-# =====================================================
-# MODEL NORMALIZER
-# =====================================================
-
-def normalize_model(model: str):
-
-    if not model:
-        return model
-
-    model_map = {
-
-        # Claude
-        "claude-sonnet-4-6": "gpt-4o",
-        "claude-sonnet-4": "gpt-4o",
-        "claude-4-sonnet": "gpt-4o",
-        "claude-3-7-sonnet": "gpt-4o",
-        "claude-3.7-sonnet": "gpt-4o",
-        "claude-opus-4": "gpt-4o",
-        "claude-opus-4-6": "gpt-4o",
-        "claude-opus-4-7": "gpt-4o",
-        "claude-haiku-4": "gpt-4o-mini",
-
-        # GPT
-        "gpt-5": "gpt-4o",
-        "gpt-5-mini": "gpt-4o-mini",
-        "gpt-4.1": "gpt-4o",
-        "gpt-4.1-mini": "gpt-4o-mini",
-
-        # Gemini
-        "gemini-2.5-pro": "gemini",
-        "gemini-2.5-flash": "gemini",
-
-        # Grok
-        "grok-4": "gpt-4o",
-        "grok-4-fast": "gpt-4o-mini",
-    }
-
-    return model_map.get(model, model)
-
-
 # =====================================================
 # CHAT COMPLETIONS
 # =====================================================
@@ -214,7 +245,9 @@ async def chat_completions(
 
     verify_api_key(req)
 
-    model = normalize_model(body.model)
+    model = normalize_model(
+        body.model
+    )
 
     messages = [
         {
@@ -240,7 +273,7 @@ async def chat_completions(
 
             try:
 
-                client = Client()
+                client = create_client()
 
                 response = client.chat.completions.create(
                     model=model,
@@ -248,8 +281,6 @@ async def chat_completions(
                     stream=True
                 )
 
-                has_content = False
-
                 for chunk in response:
 
                     try:
@@ -264,13 +295,15 @@ async def chat_completions(
                             and chunk.choices[0].delta
                             and chunk.choices[0].delta.content
                         ):
-                            content = chunk.choices[0].delta.content
+                            content = (
+                                chunk
+                                .choices[0]
+                                .delta.content
+                            )
 
                         if not content:
                             continue
 
-                        has_content = True
-
                         payload = {
                             "id": chunk_id,
                             "object": "chat.completion.chunk",
@@ -302,21 +335,6 @@ async def chat_completions(
                             f"Chunk error: {chunk_error}"
                         )
 
-                if not has_content:
-
-                    error_payload = {
-                        "error": {
-                            "message": "Provider returned empty stream",
-                            "type": "empty_stream"
-                        }
-                    }
-
-                    yield (
-                        "data: "
-                        + json.dumps(error_payload)
-                        + "\n\n"
-                    )
-
                 final_payload = {
                     "id": chunk_id,
                     "object": "chat.completion.chunk",
@@ -345,16 +363,13 @@ async def chat_completions(
                     f"Streaming error: {e}"
                 )
 
-                error_payload = {
-                    "error": {
-                        "message": str(e),
-                        "type": "server_error"
-                    }
-                }
-
                 yield (
                     "data: "
-                    + json.dumps(error_payload)
+                    + json.dumps({
+                        "error": {
+                            "message": str(e)
+                        }
+                    })
                     + "\n\n"
                 )
 
@@ -371,12 +386,12 @@ async def chat_completions(
         )
 
     # =================================================
-    # NORMAL RESPONSE
+    # NORMAL
     # =================================================
 
     try:
 
-        client = Client()
+        client = create_client()
 
         response = client.chat.completions.create(
             model=model,
@@ -452,16 +467,16 @@ async def anthropic_messages(
 
     verify_api_key(req)
 
+    requested_model = body.get("model")
+
     model = normalize_model(
-        body.get("model")
+        requested_model
     )
 
     messages = body.get("messages", [])
 
-    stream = True
-
     logger.info(
-        f"Anthropic request model={model} stream={stream}"
+        f"Anthropic request model={model} stream=True"
     )
 
     converted_messages = []
@@ -493,153 +508,187 @@ async def anthropic_messages(
             "content": content
         })
 
-    # =============================================
-    # STREAM
-    # =============================================
-
-    if stream:
-
-        def generate_stream():
-
-            try:
-
-                client = Client()
+    def generate_stream():
 
-                response = client.chat.completions.create(
-                    model=model,
-                    messages=converted_messages,
-                    stream=True
-                )
+        message_id = f"msg_{uuid.uuid4().hex}"
 
-                for chunk in response:
-
-                    try:
+        try:
 
-                        content = ""
+            client = create_client()
 
-                        if (
-                            hasattr(chunk, "choices")
-                            and chunk.choices
-                            and len(chunk.choices) > 0
-                            and hasattr(chunk.choices[0], "delta")
-                            and chunk.choices[0].delta
-                            and chunk.choices[0].delta.content
-                        ):
-                            content = chunk.choices[0].delta.content
+            response = client.chat.completions.create(
+                model=model,
+                messages=converted_messages,
+                stream=True
+            )
 
-                        if not content:
-                            continue
+            # =========================================
+            # message_start
+            # =========================================
 
-                        payload = {
-                            "type": "content_block_delta",
-                            "delta": {
-                                "type": "text_delta",
-                                "text": content
-                            }
+            yield (
+                "event: message_start\n"
+                "data: "
+                + json.dumps({
+                    "type": "message_start",
+                    "message": {
+                        "id": message_id,
+                        "type": "message",
+                        "role": "assistant",
+                        "model": requested_model,
+                        "content": [],
+                        "stop_reason": None,
+                        "stop_sequence": None,
+                        "usage": {
+                            "input_tokens": 0,
+                            "output_tokens": 0
                         }
+                    }
+                })
+                + "\n\n"
+            )
 
-                        yield (
-                            "data: "
-                            + json.dumps(
-                                payload,
-                                ensure_ascii=False
-                            )
-                            + "\n\n"
-                        )
-
-                    except Exception as e:
-
-                        logger.error(
-                            f"Anthropic chunk error: {e}"
-                        )
+            # =========================================
+            # content_block_start
+            # =========================================
 
-                yield (
-                    "data: "
-                    + json.dumps({
-                        "type": "message_stop"
-                    })
-                    + "\n\n"
-                )
+            yield (
+                "event: content_block_start\n"
+                "data: "
+                + json.dumps({
+                    "type": "content_block_start",
+                    "index": 0,
+                    "content_block": {
+                        "type": "text",
+                        "text": ""
+                    }
+                })
+                + "\n\n"
+            )
 
-            except Exception as e:
+            for chunk in response:
 
-                logger.error(
-                    f"Anthropic stream error: {e}"
-                )
+                try:
 
-                yield (
-                    "data: "
-                    + json.dumps({
-                        "error": str(e)
-                    })
-                    + "\n\n"
-                )
+                    content = ""
 
-        return StreamingResponse(
-            generate_stream(),
-            media_type="text/event-stream"
-        )
+                    if (
+                        hasattr(chunk, "choices")
+                        and chunk.choices
+                        and len(chunk.choices) > 0
+                        and hasattr(chunk.choices[0], "delta")
+                        and chunk.choices[0].delta
+                        and chunk.choices[0].delta.content
+                    ):
+                        content = (
+                            chunk
+                            .choices[0]
+                            .delta.content
+                        )
 
-    # =============================================
-    # NORMAL
-    # =============================================
+                    if not content:
+                        continue
 
-    try:
+                    payload = {
+                        "type": "content_block_delta",
+                        "index": 0,
+                        "delta": {
+                            "type": "text_delta",
+                            "text": content
+                        }
+                    }
 
-        client = Client()
+                    yield (
+                        "event: content_block_delta\n"
+                        "data: "
+                        + json.dumps(
+                            payload,
+                            ensure_ascii=False
+                        )
+                        + "\n\n"
+                    )
 
-        response = client.chat.completions.create(
-            model=model,
-            messages=converted_messages,
-            stream=False
-        )
+                except Exception as e:
 
-        text = ""
+                    logger.error(
+                        f"Anthropic chunk error: {e}"
+                    )
 
-        try:
+            # =========================================
+            # content_block_stop
+            # =========================================
 
-            text = (
-                response
-                .choices[0]
-                .message
-                .content
+            yield (
+                "event: content_block_stop\n"
+                "data: "
+                + json.dumps({
+                    "type": "content_block_stop",
+                    "index": 0
+                })
+                + "\n\n"
             )
 
-        except Exception:
-
-            text = str(response)
-
-        return {
-
-            "id": f"msg_{uuid.uuid4().hex}",
+            # =========================================
+            # message_delta
+            # =========================================
+
+            yield (
+                "event: message_delta\n"
+                "data: "
+                + json.dumps({
+                    "type": "message_delta",
+                    "delta": {
+                        "stop_reason": "end_turn",
+                        "stop_sequence": None
+                    },
+                    "usage": {
+                        "output_tokens": 0
+                    }
+                })
+                + "\n\n"
+            )
 
-            "type": "message",
+            # =========================================
+            # message_stop
+            # =========================================
 
-            "role": "assistant",
+            yield (
+                "event: message_stop\n"
+                "data: "
+                + json.dumps({
+                    "type": "message_stop"
+                })
+                + "\n\n"
+            )
 
-            "model": model,
+        except Exception as e:
 
-            "content": [
-                {
-                    "type": "text",
-                    "text": text
-                }
-            ],
+            logger.error(
+                f"Anthropic stream error: {e}"
+            )
 
-            "stop_reason": "end_turn"
+            yield (
+                "event: error\n"
+                "data: "
+                + json.dumps({
+                    "type": "error",
+                    "error": {
+                        "type": "api_error",
+                        "message": str(e)
+                    }
+                })
+                + "\n\n"
+            )
 
+    return StreamingResponse(
+        generate_stream(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no"
         }
-
-    except Exception as e:
-
-        logger.error(
-            f"Anthropic error: {e}"
-        )
-
-        raise HTTPException(
-            status_code=500,
-            detail=str(e)
-        )
+    )
 
 
 # =====================================================