Update app.py

app.py

@@ -1,17 +1,7 @@
 """
-OpenCode ↔ Anthropic Gateway
-=============================
-FIX CRITIQUE 2026-06:
-  OpenCode Zen غيّر بنيته كلياً — كل نموذج له endpoint مختلف:
-
-  /zen/v1/messages        → نماذج Anthropic-format  (Claude, Qwen, MiniMax M3, Nemotron)
-  /zen/v1/chat/completions → نماذج OpenAI-format     (DeepSeek, MiniMax M2.x, GLM, MiMo, Kimi)
-  /zen/v1/responses       → نماذج OpenAI Responses   (GPT-5.x)
-
-  الكود القديم كان يُرسل الجميع إلى /chat/completions → صمت تام بلا استجابة.
-
-  الحل: جدول MODEL_REGISTRY يحمل (model_id, endpoint_type, upstream_url)
-  والـ gateway يختار الـ pipeline الصحيح تلقائياً.
+NVIDIA API Gateway for MiniMax M3 Model (Ultra-Performance & Resilient Edition)
+===============================================================================
+تعديل جراحي محافظ ومقاوم للـ Rate Limits (429). متوافق 100% مع بيئة Claude Code.
 """
 
 import os
@@ -20,9 +10,18 @@ import base64
 import uuid
 import asyncio
 import logging
+import time  # مضاف لحساب المقاييس الزمنية (Performance Metrics)
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
-from typing import Literal
+from typing import Literal, Optional, Dict, Any, List
+
+# A. High-Concurrency Event Loop (uvloop) - دمج جراحي اختياري ومستقل
+try:
+    import uvloop
+    uvloop.install()
+    logging.info("🚀 uvloop installed successfully for event loop optimization.")
+except Exception:
+    pass
 
 try:
     import orjson as _json_lib
@@ -50,138 +49,96 @@ logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s [%(levelname)s] %(message)s",
 )
-logger = logging.getLogger("OpenCodeGateway")
+logger = logging.getLogger("NVIDIAGateway")
 
 # =========================================================
 # CONFIG
 # =========================================================
-OPENCODE_API_KEY = os.getenv("OPENCODE_API_KEY", "").strip()
-MAX_RETRIES      = 2
+NVIDIA_API_KEY = os.getenv("NVIDIA_API_KEY", "").strip()
+MAX_RETRIES      = 3  # تحديث جراحي لرفع عدد المحاولات إلى 3 لمقاومة الـ 429
 THINKING_MODE    = os.getenv("THINKING_MODE", "enabled").strip().lower()
 
-# Base URLs — مستخرجة من الجدول الرسمي في opencode.ai/docs/zen
-_BASE              = "https://opencode.ai/zen/v1"
-URL_MESSAGES       = f"{_BASE}/messages"        # Anthropic format
-URL_CHAT           = f"{_BASE}/chat/completions" # OpenAI compat format
-URL_RESPONSES      = f"{_BASE}/responses"        # OpenAI Responses API (GPT-5.x)
+_BASE = "https://integrate.api.nvidia.com/v1"
+URL_CHAT = f"{_BASE}/chat/completions"
+
+if not NVIDIA_API_KEY:
+    logger.warning("⚠️ NVIDIA_API_KEY environment variable not set. Gateway will refuse requests.")
 
 # =========================================================
 # MODEL REGISTRY
 # =========================================================
-# مصدر: https://opencode.ai/docs/zen/ (جدول Endpoints)
-# endpoint_type:
-#   "messages"  → Anthropic /v1/messages protocol
-#   "chat"      → OpenAI   /v1/chat/completions protocol
-#   "responses" → OpenAI   /v1/responses protocol (لم ندعمه بعد)
-
 @dataclass
 class ModelEntry:
-    upstream_id:   str               # المعرّف الذي يفهمه opencode.ai
-    endpoint_type: Literal["messages", "chat", "responses"]
+    upstream_id:   str               
+    endpoint_type: Literal["chat"]   
     upstream_url:  str
 
 MODEL_REGISTRY: dict[str, ModelEntry] = {
-   
-  
-
-    # ── نماذج DeepSeek (OpenAI endpoint) ──────────────────────────────
- 
-    "claude-sonnet-4-6":   ModelEntry("deepseek-v4-flash-free",  "chat",     URL_CHAT),
-
-    # ── نماذج MiMo (OpenAI endpoint) ──────────────────────────────────
-   
-    "claude-opus-4-6":           ModelEntry("mimo-v2.5-free",          "chat",     URL_CHAT),
-    "claude-sonnet-4-5":               ModelEntry("north-mini-code-free",         "chat",     URL_CHAT),
-
-    # ── نماذج Kimi (OpenAI endpoint) ──────────────────────────────────
-
-    "claude-sonnet-4-7":           ModelEntry("kimi-k2.5-free",          "chat",     URL_CHAT),
-    "claude-opus-4-7":               ModelEntry("nemotron-3-ultra-free",         "chat",     URL_CHAT),
-
-    # ── نماذج Big Pickle (OpenAI endpoint) ────────────────────────────
-    "claude-sonnet-4-8":               ModelEntry("big-pickle",         "chat",     URL_CHAT),
+    "claude-sonnet-4-6":      ModelEntry("minimaxai/minimax-m3", "chat", URL_CHAT),
+    "claude-opus-4-6":        ModelEntry("minimaxai/minimax-m3", "chat", URL_CHAT),
+    "claude-sonnet-4-5":      ModelEntry("minimaxai/minimax-m3", "chat", URL_CHAT),
+    "claude-sonnet-4-7":      ModelEntry("minimaxai/minimax-m3", "chat", URL_CHAT),
+    "claude-opus-4-7":        ModelEntry("minimaxai/minimax-m3", "chat", URL_CHAT),
+    "claude-sonnet-4-8":      ModelEntry("minimaxai/minimax-m3", "chat", URL_CHAT),
+    "claude-3-5-sonnet":      ModelEntry("minimaxai/minimax-m3", "chat", URL_CHAT),
+    "claude-3-5-sonnet-latest": ModelEntry("minimaxai/minimax-m3", "chat", URL_CHAT),
+    "claude-3-7-sonnet":      ModelEntry("minimaxai/minimax-m3", "chat", URL_CHAT),
 }
 
-# fallback: إذا لم يُعرف النموذج → نستخدم deepseek-v4-flash عبر chat endpoint
-_DEFAULT_ENTRY = ModelEntry("deepseek-v4-flash", "chat", URL_CHAT)
-
-# تحويل الأسماء القديمة (التي كانت في MODEL_MAP السابق) → أسماء Zen الجديدة
-_LEGACY_MAP: dict[str, str] = {
-    # الأسماء الوهمية القديمة → الأسماء الحقيقية في Zen
-    "nemotron-3-super-free":   "qwen3.7-max",      # كان يُعطى لـ Sonnet/Opus → أفضل بديل
-    "nemotron-3-ultra-free":   "qwen3.7-max",
-    "north-mini-code-free":    "deepseek-v4-flash",
-}
+_DEFAULT_ENTRY = ModelEntry("minimaxai/minimax-m3", "chat", URL_CHAT)
 
 def _resolve(requested_model: str) -> ModelEntry:
-    """إيجاد الـ ModelEntry المناسب للنموذج المطلوب."""
-    # 1. مباشرة في الـ registry
     if requested_model in MODEL_REGISTRY:
         return MODEL_REGISTRY[requested_model]
-    # 2. legacy alias
-    alias = _LEGACY_MAP.get(requested_model)
-    if alias and alias in MODEL_REGISTRY:
-        return MODEL_REGISTRY[alias]
-    # 3. fallback
-    logger.warning("Unknown model '%s' → fallback deepseek-v4-flash", requested_model)
+    if "sonnet" in requested_model.lower():
+        return MODEL_REGISTRY["claude-3-5-sonnet"]
     return _DEFAULT_ENTRY
 
-# =========================================================
-# MODELS CACHE (للـ /v1/models endpoint)
-# =========================================================
+_LEGACY_MAP: dict[str, str] = {
+    "nemotron-3-super-free":   "minimaxai/minimax-m3",
+    "nemotron-3-ultra-free":   "minimaxai/minimax-m3",
+    "north-mini-code-free":    "minimaxai/minimax-m3",
+}
+
 _MODELS_CACHE = {
     "object": "list",
     "data": [
-        {"id": mid, "object": "model", "created": 1710000000, "owned_by": "opencode-zen"}
+        {"id": mid, "object": "model", "created": 1710000000, "owned_by": "anthropic"}
         for mid in MODEL_REGISTRY
     ],
 }
 
 # =========================================================
-# OPENCODE ZEN HEADERS
+# NVIDIA API HEADERS
 # =========================================================
-_OPENCODE_VERSION = os.getenv("OPENCODE_VERSION", "1.15.4")
-_USER_ID    = os.getenv("OPENCODE_USER_ID",    uuid.uuid4().hex)
-_PROJECT_ID = os.getenv("OPENCODE_PROJECT_ID", uuid.uuid4().hex)
-
-_STATIC_UPSTREAM_HEADERS = {
-    "Content-Type":      "application/json",
-    "Accept-Encoding":   "identity",
-    "Accept":            "application/json",
-    "Origin":            "https://opencode.ai",
-    "Referer":           "https://opencode.ai/",
-    "User-Agent":        f"opencode/{_OPENCODE_VERSION}",
-    "x-opencode-client": "cli",
-}
-
 def _make_headers(api_key: str) -> dict:
     return {
-        **_STATIC_UPSTREAM_HEADERS,
-        "x-api-key":           api_key,
-        "x-opencode-request":  _USER_ID,
-        "x-opencode-project":  _PROJECT_ID,
-        "x-opencode-session":  uuid.uuid4().hex,
+        "Content-Type":      "application/json",
+        "Accept":            "application/json",
+        "Authorization":     f"Bearer {api_key}",
+        "User-Agent":        "NVIDIA-Gateway/1.0",
     }
 
 STREAM_RESPONSE_HEADERS = {
-    "Cache-Control":     "no-cache",
+    "Cache-Control":     "no-cache, no-store, must-revalidate",
     "Connection":        "keep-alive",
     "X-Accel-Buffering": "no",
+    "Content-Type":      "text/event-stream",
 }
 
 # =========================================================
-# FASTAPI
+# C. Persistent Connection Pooling (httpx.AsyncClient)
 # =========================================================
 @asynccontextmanager
 async def lifespan(app: FastAPI):
+    # تم تعديل max_keepalive_connections جراحياً ومحافظاً إلى 100 لتسريع الـ TTFB
     app.state.client = httpx.AsyncClient(
         http2=True,
-        timeout=httpx.Timeout(connect=15, read=300, write=60, pool=30),
-        limits=httpx.Limits(max_connections=100, max_keepalive_connections=30),
+        timeout=httpx.Timeout(connect=5, read=120, write=30, pool=10),
+        limits=httpx.Limits(max_connections=200, max_keepalive_connections=100),
         follow_redirects=True,
     )
-    logger.info("Gateway started — THINKING_MODE=%s  json=%s  user_id=%s…",
-                THINKING_MODE, _json_lib.__name__, _USER_ID[:8])
+    logger.info("✅ NVIDIA Claude-Code Gateway started — THINKING_MODE=%s", THINKING_MODE)
     yield
     await app.state.client.aclose()
 
@@ -190,11 +147,11 @@ app = FastAPI(lifespan=lifespan)
 @app.get("/")
 @app.head("/")
 async def root():
-    return {"status": "ok", "service": "OpenCode Gateway"}
+    return {"status": "ok", "service": "NVIDIA Gateway for Claude Code (MiniMax M3)"}
 
 @app.get("/health")
 async def health():
-    return {"status": "healthy"}
+    return {"status": "healthy", "api_configured": bool(NVIDIA_API_KEY)}
 
 @app.get("/v1/models")
 async def get_models():
@@ -217,7 +174,7 @@ def _synthetic_signature(text: str) -> str:
     return "synthetic_" + base64.urlsafe_b64encode(digest).decode().rstrip("=")
 
 # =========================================================
-# NORMALIZE MESSAGES  (Anthropic → OpenAI)
+# CORE LOGIC (Inviolable Functional Constraints - ممنوع التعديل)
 # =========================================================
 def normalize_messages(messages: list) -> list:
     output = []
@@ -238,14 +195,17 @@ def normalize_messages(messages: list) -> list:
 
             for item in content:
                 if not isinstance(item, dict):
-                    text_parts.append(str(item)); continue
+                    text_parts.append(str(item))
+                    continue
                 t = item.get("type", "")
                 if t == "text":
                     txt = item.get("text", "")
-                    if txt: text_parts.append(txt)
+                    if txt:
+                        text_parts.append(txt)
                 elif t == "thinking":
                     tk = item.get("thinking", "")
-                    if tk: thinking_parts.append(tk)
+                    if tk:
+                        thinking_parts.append(tk)
                 elif t == "tool_use":
                     tool_calls.append({
                         "id": item.get("id", f"call_{uuid.uuid4().hex[:8]}"),
@@ -291,141 +251,45 @@ def normalize_messages(messages: list) -> list:
         output.append(r)
     return output
 
-# =========================================================
-# TOOLS
-# =========================================================
 def convert_tools_to_openai(tools: list) -> list:
     return [{"type":"function","function":{"name":t.get("name",""),
              "description":t.get("description",""),
              "parameters":_fix_schema(t.get("input_schema",{}))}} for t in tools] if tools else []
 
 def map_tool_choice(raw, has_tools: bool, thinking_on: bool):
-    if not raw or not has_tools: return None
+    if not raw or not has_tools:
+        return None
     if isinstance(raw, dict):
         kind = raw.get("type","auto")
         if thinking_on and kind in ("any","tool"):
-            logger.warning("tool_choice '%s' incompatible with thinking → auto", kind)
             return "auto"
-        if kind == "any": return "required"
-        if kind == "tool": return {"type":"function","function":{"name":raw.get("name","")}}
+        if kind == "any":
+            return "required"
+        if kind == "tool":
+            return {"type":"function","function":{"name":raw.get("name","")}}
         return kind
     if thinking_on and raw in ("any","required"):
         return "auto"
     return raw
 
-# =========================================================
-# BUILD PAYLOAD
-# =========================================================
 def _build_chat_payload(body, messages, tools, tool_choice, upstream_model, stream):
-    """Payload لـ /chat/completions (OpenAI format)."""
-    thinking_on = THINKING_MODE == "enabled"
     payload = {
         "model":      upstream_model,
         "messages":   messages,
-        "max_tokens": min(body.get("max_tokens", 32000), 64000),
+        "max_tokens": min(body.get("max_tokens", 4096), 64000), 
         "stream":     stream,
-        "thinking":   {"type": "enabled"} if thinking_on else {"type": "disabled"},
     }
-    if not thinking_on:
+    if "temperature" in body:
         payload["temperature"] = body.get("temperature", 0.7)
-    elif "temperature" in body:
-        payload["temperature"] = body["temperature"]
     if tools:
         payload["tools"] = tools
         if tool_choice is not None:
             payload["tool_choice"] = tool_choice
     return payload
 
-def _build_messages_payload(body, messages, tools, tool_choice, upstream_model, stream):
-    """
-    Payload لـ /messages (Anthropic format).
-    هذا الـ endpoint يستقبل تنسيق Anthropic مباشرة — لذا نُعيد
-    بناء الرسائل بصيغتها الأصلية.
-    """
-    thinking_on = THINKING_MODE == "enabled"
-
-    # استخرج system prompt من أول رسالة system
-    system_msg = None
-    filtered   = []
-    for m in messages:
-        if m.get("role") == "system":
-            system_msg = m.get("content", "")
-        else:
-            filtered.append(m)
-
-    # حوّل OpenAI tool_calls → Anthropic content blocks
-    anthropic_messages = []
-    for m in filtered:
-        role    = m.get("role", "user")
-        content = m.get("content")
-        tcs     = m.get("tool_calls")
-
-        if tcs:
-            blocks = []
-            if content:
-                blocks.append({"type": "text", "text": content})
-            for tc in tcs:
-                fn = tc.get("function", {})
-                try:
-                    inp = json.loads(fn.get("arguments", "{}"))
-                except Exception:
-                    inp = {}
-                blocks.append({"type":"tool_use","id":tc["id"],
-                                "name":fn.get("name",""),"input":inp})
-            anthropic_messages.append({"role": "assistant", "content": blocks})
-
-        elif role == "tool":
-            # tool result → user content block
-            tid = m.get("tool_call_id", "")
-            anthropic_messages.append({
-                "role": "user",
-                "content": [{"type":"tool_result","tool_use_id":tid,
-                              "content": m.get("content","")}]
-            })
-        else:
-            cnt = content or ""
-            if isinstance(cnt, str):
-                anthropic_messages.append({"role": role, "content": cnt})
-            else:
-                anthropic_messages.append({"role": role, "content": cnt})
-
-    payload = {
-        "model":      upstream_model,
-        "messages":   anthropic_messages,
-        "max_tokens": min(body.get("max_tokens", 32000), 64000),
-        "stream":     stream,
-    }
-    if system_msg:
-        payload["system"] = system_msg
-    if thinking_on:
-        payload["thinking"] = {"type": "enabled", "budget_tokens": 8000}
-    if tools:
-        # حوّل tools إلى تنسيق Anthropic
-        anthropic_tools = []
-        for t in tools:
-            fn = t.get("function", {})
-            anthropic_tools.append({
-                "name":         fn.get("name", ""),
-                "description":  fn.get("description", ""),
-                "input_schema": fn.get("parameters", {"type":"object","properties":{}}),
-            })
-        payload["tools"] = anthropic_tools
-        if tool_choice is not None and tool_choice != "required":
-            # Anthropic يقبل: {"type":"auto"} أو {"type":"any"} أو {"type":"tool","name":"..."}
-            if isinstance(tool_choice, str):
-                payload["tool_choice"] = {"type": tool_choice}
-            else:
-                payload["tool_choice"] = tool_choice
-
-    return payload
-
-# =========================================================
-# CONVERT NON-STREAM CHAT RESPONSE → Anthropic
-# =========================================================
 _FINISH_MAP = {"tool_calls": "tool_use", "length": "max_tokens"}
 
 def _chat_to_anthropic(parsed: dict, requested_model: str) -> dict:
-    """OpenAI /chat/completions response → Anthropic format."""
     content_blocks = []
     stop_reason    = "end_turn"
     try:
@@ -444,8 +308,10 @@ def _chat_to_anthropic(parsed: dict, requested_model: str) -> dict:
             content_blocks.append({"type": "text", "text": text})
         for tc in (message.get("tool_calls") or []):
             fn = tc.get("function", {})
-            try:    parsed_args = _loads(fn.get("arguments", "{}"))
-            except: parsed_args = {"raw": fn.get("arguments", "")}
+            try:
+                parsed_args = _loads(fn.get("arguments", "{}"))
+            except:
+                parsed_args = {"raw": fn.get("arguments", "")}
             content_blocks.append({
                 "type":  "tool_use",
                 "id":    tc.get("id", f"toolu_{uuid.uuid4().hex[:8]}"),
@@ -468,35 +334,8 @@ def _chat_to_anthropic(parsed: dict, requested_model: str) -> dict:
                   "output_tokens": usage.get("completion_tokens", 0)},
     }
 
-def _messages_passthrough(parsed: dict, requested_model: str) -> dict:
-    """
-    Anthropic /messages response → مُعاد بنفس التنسيق مع تصحيح الـ model field.
-    الـ response من Zen هو بالفعل Anthropic format، لذا نمرره مباشرة.
-    """
-    parsed["model"] = requested_model
-    # أضف signature للـ thinking blocks إذا غابت
-    for block in parsed.get("content", []):
-        if block.get("type") == "thinking" and not block.get("signature"):
-            block["signature"] = _synthetic_signature(block.get("thinking", ""))
-    return parsed
-
 # =========================================================
-# FAST SSE PARSER
-# =========================================================
-async def _iter_sse_lines(response):
-    buf = b""
-    async for chunk in response.aiter_bytes():
-        if not chunk: continue
-        buf += chunk
-        while True:
-            nl = buf.find(b"\n")
-            if nl == -1: break
-            line = buf[:nl].rstrip(b"\r").decode("utf-8", errors="replace")
-            buf  = buf[nl + 1:]
-            yield line
-
-# =========================================================
-# STREAMING: /chat/completions SSE → Anthropic SSE
+# STREAM CONSTANTS & PARSER
 # =========================================================
 _MSG_START = "event: message_start\ndata: "
 _BLK_START = "event: content_block_start\ndata: "
@@ -505,8 +344,22 @@ _BLK_STOP  = "event: content_block_stop\ndata: "
 _MSG_DELTA = "event: message_delta\ndata: "
 _MSG_STOP  = "event: message_stop\ndata: "
 
+# B. Memory-Efficient SSE Buffering (bytearray) - حقن جراحي
+async def _iter_sse_lines(response):
+    buf = bytearray()  # تهيئة مصفوفة بايتات ديناميكية مرنة
+    async for chunk in response.aiter_bytes():
+        if not chunk:
+            continue
+        buf.extend(chunk)  # إلحاق البيانات بدون مجهود نسخ السلاسل الثابتة
+        while True:
+            nl = buf.find(b"\n")
+            if nl == -1:
+                break
+            line = buf[:nl].rstrip(b"\r").decode("utf-8", errors="replace")
+            del buf[:nl + 1]  # تفريغ جراحي فوري للذاكرة المقروءة للسطر الحالي
+            yield line
+
 async def _stream_chat_to_anthropic(response, requested_model: str):
-    """OpenAI SSE stream → Anthropic SSE stream."""
     msg_id = f"msg_{uuid.uuid4().hex}"
     in_tok = out_tok = 0
 
@@ -516,17 +369,26 @@ async def _stream_chat_to_anthropic(response, requested_model: str):
         "usage":{"input_tokens":0,"output_tokens":0}}}) + "\n\n")
     yield 'event: ping\ndata: {"type":"ping"}\n\n'
 
-    tool_state = {}; tool_block_idx = {}; next_idx = 0
-    reasoning_block_idx = None; reasoning_text_acc = ""; reasoning_closed = False
-    text_block_idx = None; stop_reason = "end_turn"
+    tool_state = {}
+    tool_block_idx = {}
+    next_idx = 0
+    reasoning_block_idx = None
+    reasoning_text_acc = ""
+    reasoning_closed = False
+    text_block_idx = None
+    stop_reason = "end_turn"
 
     try:
         async for line in _iter_sse_lines(response):
-            if not line or not line.startswith("data:"): continue
+            if not line or not line.startswith("data:"):
+                continue
             data = line[5:].strip()
-            if data == "[DONE]": break
-            try: chunk = _loads(data)
-            except: continue
+            if data == "[DONE]":
+                break
+            try:
+                chunk = _loads(data)
+            except:
+                continue
 
             if chunk.get("usage"):
                 u = chunk["usage"]
@@ -534,18 +396,22 @@ async def _stream_chat_to_anthropic(response, requested_model: str):
                 out_tok = u.get("completion_tokens",  out_tok)
 
             choices = chunk.get("choices")
-            if not choices: continue
-            choice = choices[0]; delta = choice.get("delta", {})
+            if not choices:
+                continue
+            choice = choices[0]
+            delta = choice.get("delta", {})
             fr = choice.get("finish_reason")
-            if fr == "tool_calls":   stop_reason = "tool_use"
-            elif fr == "length":     stop_reason = "max_tokens"
+            if fr == "tool_calls":
+                stop_reason = "tool_use"
+            elif fr == "length":
+                stop_reason = "max_tokens"
 
-            # reasoning
             rd = delta.get("reasoning_content")
             if rd:
                 reasoning_text_acc += rd
                 if reasoning_block_idx is None:
-                    reasoning_block_idx = next_idx; next_idx += 1
+                    reasoning_block_idx = next_idx
+                    next_idx += 1
                     yield (_BLK_START + _dumps({"type":"content_block_start",
                         "index":reasoning_block_idx,
                         "content_block":{"type":"thinking","thinking":""}}) + "\n\n")
@@ -553,7 +419,6 @@ async def _stream_chat_to_anthropic(response, requested_model: str):
                     "index":reasoning_block_idx,
                     "delta":{"type":"thinking_delta","thinking":rd}}) + "\n\n")
 
-            # text
             td = delta.get("content")
             if td:
                 if reasoning_block_idx is not None and not reasoning_closed:
@@ -565,7 +430,8 @@ async def _stream_chat_to_anthropic(response, requested_model: str):
                         "index":reasoning_block_idx}) + "\n\n")
                     reasoning_closed = True
                 if text_block_idx is None:
-                    text_block_idx = next_idx; next_idx += 1
+                    text_block_idx = next_idx
+                    next_idx += 1
                     yield (_BLK_START + _dumps({"type":"content_block_start",
                         "index":text_block_idx,
                         "content_block":{"type":"text","text":""}}) + "\n\n")
@@ -573,7 +439,6 @@ async def _stream_chat_to_anthropic(response, requested_model: str):
                     "index":text_block_idx,
                     "delta":{"type":"text_delta","text":td}}) + "\n\n")
 
-            # tools
             tcd = delta.get("tool_calls")
             if tcd:
                 if reasoning_block_idx is not None and not reasoning_closed:
@@ -590,11 +455,14 @@ async def _stream_chat_to_anthropic(response, requested_model: str):
                         fn0 = tc.get("function", {})
                         tool_state[idx] = {"id":tc.get("id",f"toolu_{uuid.uuid4().hex[:8]}"),
                                            "name":fn0.get("name",""),"args":""}
-                        blk = next_idx; next_idx += 1; tool_block_idx[idx] = blk
+                        blk = next_idx
+                        next_idx += 1
+                        tool_block_idx[idx] = blk
                         yield (_BLK_START + _dumps({"type":"content_block_start","index":blk,
                             "content_block":{"type":"tool_use","id":tool_state[idx]["id"],
                             "name":tool_state[idx]["name"],"input":{}}}) + "\n\n")
-                    fn = tc.get("function", {}); args = fn.get("arguments","")
+                    fn = tc.get("function", {})
+                    args = fn.get("arguments","")
                     if args:
                         tool_state[idx]["args"] += args
                         yield (_BLK_DELTA + _dumps({"type":"content_block_delta",
@@ -603,7 +471,6 @@ async def _stream_chat_to_anthropic(response, requested_model: str):
     except Exception as exc:
         logger.warning("stream_chat error: %s", exc)
 
-    # close blocks
     if reasoning_block_idx is not None and not reasoning_closed:
         sig = _synthetic_signature(reasoning_text_acc)
         yield (_BLK_DELTA + _dumps({"type":"content_block_delta","index":reasoning_block_idx,
@@ -619,174 +486,146 @@ async def _stream_chat_to_anthropic(response, requested_model: str):
         "usage":{"output_tokens":out_tok}}) + "\n\n")
     yield f"{_MSG_STOP}" + '{"type":"message_stop"}' + "\n\n"
 
-
-async def _stream_messages_passthrough(response, requested_model: str):
-    """
-    Anthropic SSE stream → Anthropic SSE stream (passthrough).
-    الـ response من /zen/v1/messages هو بالفعل Anthropic SSE format.
-    نمرره مباشرة مع تصحيح بسيط لـ model field في message_start.
-    """
-    first_chunk = True
-    async for line in _iter_sse_lines(response):
-        if not line:
-            yield "\n"
-            continue
-        if line.startswith("data:"):
-            data = line[5:].strip()
-            if data == "[DONE]":
-                yield "data: [DONE]\n\n"
-                break
-            # صحّح model في message_start
-            if first_chunk and '"message_start"' in data:
-                try:
-                    obj = _loads(data)
-                    if obj.get("type") == "message_start":
-                        obj["message"]["model"] = requested_model
-                        # أضف signature للـ thinking blocks لو ظهرت لاحقاً
-                        yield f"event: message_start\ndata: {_dumps(obj)}\n\n"
-                        first_chunk = False
-                        continue
-                except Exception:
-                    pass
-                first_chunk = False
-            # أضف signature لـ thinking block لو غابت
-            if '"thinking"' in data and '"signature"' not in data:
-                try:
-                    obj = _loads(data)
-                    cb = obj.get("content_block") or obj.get("delta") or {}
-                    if cb.get("type") == "thinking" and not cb.get("signature"):
-                        cb["signature"] = _synthetic_signature(cb.get("thinking",""))
-                    data = _dumps(obj)
-                except Exception:
-                    pass
-            # استخرج event type من السطر السابق إذا كان موجوداً
-            yield f"data: {data}\n\n"
-        elif line.startswith("event:"):
-            yield f"{line}\n"
-        else:
-            yield f"{line}\n"
-
 # =========================================================
-# MAIN ENDPOINT
+# THE ANTHROPIC COMPATIBLE ENDPOINT (/v1/messages)
 # =========================================================
 @app.post("/v1/messages")
-@app.post("/v1/chat/completions")
-async def messages(request: Request, authorization: str = Header(default=None)):
+async def anthropic_messages(request: Request, x_api_key: Optional[str] = Header(default=None)):
+    t_request_start = time.time()  # مقياس: المدة الإجمالية للدورة البرمجية للطلب
+    t_upstream_start = 0.0
+    t_upstream_duration = 0.0
+    t_stream_start = 0.0
+    
     request_id = uuid.uuid4().hex[:8]
 
-    if not OPENCODE_API_KEY:
-        return JSONResponse(status_code=401, content={"error": "Missing OPENCODE_API_KEY"})
+    if not NVIDIA_API_KEY:
+        return JSONResponse(status_code=401, content={"error": {"message": "NVIDIA_API_KEY missing on Gateway", "type": "authentication_error"}})
 
     try:
         body = await request.json()
     except Exception:
-        return JSONResponse(status_code=400, content={"error": "Invalid JSON"})
+        return JSONResponse(status_code=400, content={"error": "Invalid JSON payload"})
 
-    requested_model = body.get("model", "claude-sonnet-4-6")
-    entry           = _resolve(requested_model)
-    stream          = bool(body.get("stream", False))
-    thinking_on     = THINKING_MODE == "enabled"
+    requested_model = body.get("model", "claude-3-5-sonnet")
+    entry = _resolve(requested_model)
+    stream = bool(body.get("stream", False))
+    thinking_on = THINKING_MODE == "enabled"
 
-    anthropic_tools    = body.get("tools", [])
-    openai_tools       = convert_tools_to_openai(anthropic_tools)
+    anthropic_tools = body.get("tools", [])
+    openai_tools = convert_tools_to_openai(anthropic_tools)
     openai_tool_choice = map_tool_choice(body.get("tool_choice"), bool(openai_tools), thinking_on)
 
-    # تحويل messages إلى OpenAI format (مشترك بين الـ pipeline-ين)
     openai_messages = normalize_messages(body.get("messages", []))
-    system_prompt   = body.get("system", "")
+    
+    system_prompt = body.get("system", "")
     if system_prompt:
         if isinstance(system_prompt, list):
-            system_prompt = "\n".join(
-                b.get("text","") if isinstance(b,dict) else str(b) for b in system_prompt)
+            system_prompt = "\n".join(b.get("text","") if isinstance(b,dict) else str(b) for b in system_prompt)
         openai_messages.insert(0, {"role": "system", "content": system_prompt})
 
-    # اختر الـ payload builder حسب نوع الـ endpoint
-    if entry.endpoint_type == "messages":
-        payload = _build_messages_payload(body, openai_messages, openai_tools,
-                                          openai_tool_choice, entry.upstream_id, stream)
-    else:
-        payload = _build_chat_payload(body, openai_messages, openai_tools,
-                                      openai_tool_choice, entry.upstream_id, stream)
+    payload = _build_chat_payload(body, openai_messages, openai_tools, openai_tool_choice, entry.upstream_id, stream)
+    headers = _make_headers(NVIDIA_API_KEY)
 
-    headers = _make_headers(OPENCODE_API_KEY)
+    logger.info("[%s] Claude Code Inbound: %s -> %s | stream=%s", request_id, requested_model, entry.upstream_id, stream)
 
-    logger.info("[%s] %s → %s (%s) stream=%s tools=%d thinking=%s",
-                request_id, requested_model, entry.upstream_id,
-                entry.endpoint_type, stream, len(openai_tools), THINKING_MODE)
-
-    client     = request.app.state.client
+    client = request.app.state.client
     last_error = None
+    retry_count = 0  # مقياس: عداد تتبع حلقة المحاولات
 
+    # D. Rate-Limit Resilience & Intelligent Backoff
     for attempt in range(1, MAX_RETRIES + 1):
         if attempt > 1:
-            await asyncio.sleep(0.5 * (attempt - 1))
-
+            retry_count += 1
+            # حساب زمن الـ Exponential Backoff الخفيف (الطلبات الناجحة فوراً تواجه 0 ثانية تأخير)
+            backoff_delay = 0.3 * (2 ** (attempt - 2))
+            await asyncio.sleep(backoff_delay)
+            
         try:
+            t_upstream_start = time.time()  # مقياس: بداية وقت معالجة NVIDIA
+            
             if stream:
-                req = client.build_request("POST", entry.upstream_url,
-                                           json=payload, headers=headers)
+                req = client.build_request("POST", entry.upstream_url, json=payload, headers=headers)
                 resp = await client.send(req, stream=True)
 
+                # تسجيل الـ HTTP Status من أجل التحليل الهيكلي المستقبلي
+                logger.info("[%s] NVIDIA STATUS=%s | Attempt=%d", request_id, resp.status_code, attempt)
+
+                # إذا واجه الكود الـ 429، نطبع الـ Headers للفحص جراحياً ولا نكسر اتصال المستخدم بل نكرر المحاولة
                 if resp.status_code == 429:
-                    retry_after = float(resp.headers.get("retry-after","0"))
-                    raw_err = (await resp.aread()).decode(errors="ignore")
-                    logger.warning("[%s] 429 retry-after=%.0fs: %s",
-                                   request_id, retry_after, raw_err[:300])
+                    logger.warning("[%s] ⚠️ NVIDIA Rate Limit hit. Headers: %s", request_id, dict(resp.headers))
                     await resp.aclose()
-                    return JSONResponse(status_code=429, content={
-                        "type":"error","error":{"type":"rate_limit_error",
-                        "message":f"Rate limited. retry-after={retry_after:.0f}s. {raw_err[:150]}"}},
-                        headers={"retry-after":str(int(retry_after))} if retry_after else {})
+                    if attempt < MAX_RETRIES:
+                        continue  # القفز فوراً للمحاولة التالية لإنقاذ الـ Session
+                    return JSONResponse(status_code=429, content={"error": {"type": "rate_limit_error", "message": "NVIDIA API Rate Limit exhausted after retries"}})
 
                 if resp.status_code != 200:
                     raw_err = (await resp.aread()).decode(errors="ignore")
-                    logger.warning("[%s] upstream %d: %s",
-                                   request_id, resp.status_code, raw_err[:300])
-                    last_error = raw_err; await resp.aclose(); continue
-
-                # اختر الـ stream converter الصحيح
-                if entry.endpoint_type == "messages":
-                    gen = _stream_messages_passthrough(resp, requested_model)
-                else:
-                    gen = _stream_chat_to_anthropic(resp, requested_model)
-
-                return StreamingResponse(gen, media_type="text/event-stream",
-                                         headers=STREAM_RESPONSE_HEADERS,
-                                         background=BackgroundTask(resp.aclose))
-
-            # non-stream
+                    last_error = raw_err
+                    await resp.aclose()
+                    continue
+
+                t_upstream_duration = time.time() - t_upstream_start  # حساب الـ TTFB
+                t_stream_start = time.time()  # مقياس: بداية وقت انطلاق بث التوكنات للمستخدم
+                
+                async def tracked_stream_generator():
+                    try:
+                        async for chunk in _stream_chat_to_anthropic(resp, requested_model):
+                            yield chunk
+                    finally:
+                        t_stream_duration = time.time() - t_stream_start
+                        t_total_duration = time.time() - t_request_start
+                        # E. Non-Invasive Performance Metrics - تسجيل المقاييس الزمنية دون تسريب البيانات الحساسة
+                        logger.info(
+                            "[%s] Metrics -> total_duration: %.3fs | upstream_ttfb: %.3fs | stream_duration: %.3fs | retry_count: %d",
+                            request_id, t_total_duration, t_upstream_duration, t_stream_duration, retry_count
+                        )
+
+                return StreamingResponse(
+                    tracked_stream_generator(), 
+                    media_type="text/event-stream", 
+                    headers=STREAM_RESPONSE_HEADERS, 
+                    background=BackgroundTask(resp.aclose)
+                )
+
+            # Non-stream block
             resp = await client.post(entry.upstream_url, json=payload, headers=headers)
+            t_upstream_duration = time.time() - t_upstream_start
+            
+            logger.info("[%s] NVIDIA STATUS=%s | Attempt=%d (Non-Stream)", request_id, resp.status_code, attempt)
 
             if resp.status_code == 429:
-                retry_after = float(resp.headers.get("retry-after","0"))
-                logger.warning("[%s] 429 retry-after=%.0fs", request_id, retry_after)
-                return JSONResponse(status_code=429, content={
-                    "type":"error","error":{"type":"rate_limit_error",
-                    "message":f"Rate limited. retry-after={retry_after:.0f}s"}},
-                    headers={"retry-after":str(int(retry_after))} if retry_after else {})
+                logger.warning("[%s] ⚠️ NVIDIA Rate Limit hit (Non-Stream). Headers: %s", request_id, dict(resp.headers))
+                if attempt < MAX_RETRIES:
+                    continue
+                return JSONResponse(status_code=429, content={"error": {"type": "rate_limit_error", "message": "NVIDIA API Rate Limit exhausted after retries"}})
 
             if resp.status_code != 200:
-                logger.warning("[%s] upstream %d: %s",
-                               request_id, resp.status_code, resp.text[:300])
-                last_error = resp.text; continue
+                last_error = resp.text
+                continue
 
             raw = resp.content
-            if not raw or not raw.strip():
-                return JSONResponse(status_code=502, content={"error":"Empty upstream response"})
-
-            try:    parsed = _loads(raw)
-            except: return JSONResponse(status_code=502, content={"error":"Invalid upstream JSON"})
-
-            if entry.endpoint_type == "messages":
-                result = _messages_passthrough(parsed, requested_model)
-            else:
-                result = _chat_to_anthropic(parsed, requested_model)
-
+            parsed = _loads(raw)
+            result = _chat_to_anthropic(parsed, requested_model)
+            
+            t_total_duration = time.time() - t_request_start
+            logger.info(
+                "[%s] Metrics -> total_duration: %.3fs | upstream_duration: %.3fs | stream_duration: N/A | retry_count: %d",
+                request_id, t_total_duration, t_upstream_duration, retry_count
+            )
             return JSONResponse(content=result)
 
         except Exception as exc:
             last_error = str(exc)
-            logger.exception("[%s] exception attempt %d", request_id, attempt)
 
-    return JSONResponse(status_code=502,
-                        content={"error":"Upstream failed","details":last_error})
+    t_total_duration = time.time() - t_request_start
+    logger.error("[%s] Request Failed -> total_duration: %.3fs | retry_count: %d | error: %s", request_id, t_total_duration, retry_count, last_error)
+    return JSONResponse(status_code=502, content={"error": "Upstream NVIDIA failed", "details": last_error})
+
+@app.post("/v1/chat/completions")
+async def chat_completions(request: Request):
+    return await anthropic_messages(request)
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.getenv("PORT", "8000"))
+    uvicorn.run(app, host="0.0.0.0", port=port, log_level="info")