Update app.py

app.py

@@ -1,11 +1,18 @@
+# =========================================================
+# OpenCode Gateway
+# Anthropic API compatibility layer for OpenCode / DeepSeek
+# =========================================================
+
 import os
 import json
 import uuid
 import asyncio
 import logging
+
 from contextlib import asynccontextmanager
 
 import httpx
+
 from fastapi import FastAPI, Request, Header
 from fastapi.responses import JSONResponse, StreamingResponse
 
@@ -17,22 +24,32 @@ logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s [%(levelname)s] %(message)s"
 )
-logger = logging.getLogger("gateway")
+
+logger = logging.getLogger("OpenCodeGateway")
 
 # =========================================================
 # CONFIG
 # =========================================================
 
-OPENCODE_API_KEY = os.getenv("OPENCODE_API_KEY", "").strip()
-UPSTREAM_URL     = "https://opencode.ai/zen/v1/chat/completions"
-MAX_RETRIES      = 5
-RETRY_DELAY      = 3
+OPENCODE_API_KEY = os.getenv(
+    "OPENCODE_API_KEY",
+    ""
+).strip()
+
+UPSTREAM_URL = "https://opencode.ai/zen/v1/chat/completions"
+
+MAX_RETRIES = 2
+RETRY_DELAY = 1
+
+# =========================================================
+# HEADERS
+# =========================================================
 
 UPSTREAM_HEADERS = {
     "Content-Type": "application/json",
-    "Accept":       "application/json",
-    "Origin":       "https://opencode.ai",
-    "Referer":      "https://opencode.ai/",
+    "Accept": "application/json",
+    "Origin": "https://opencode.ai",
+    "Referer": "https://opencode.ai/",
     "User-Agent": (
         "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
         "AppleWebKit/537.36 (KHTML, like Gecko) "
@@ -40,46 +57,25 @@ UPSTREAM_HEADERS = {
     ),
 }
 
-STREAM_HEADERS = {
-    "Cache-Control":     "no-cache",
-    "Connection":        "keep-alive",
+STREAM_RESPONSE_HEADERS = {
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive",
     "X-Accel-Buffering": "no",
 }
 
 # =========================================================
-# MODEL MAP
+# MODELS
 # =========================================================
 
-# Only models confirmed working from logs (no 401)
-_FREE_POOL = [
-    "deepseek-v4-flash-free",
-    "nemotron-3-super-free",
-]
-_pool_idx = 0
-
-
-def _pick_free_model():
-    """Round-robin across confirmed free models."""
-    global _pool_idx
-    model = _FREE_POOL[_pool_idx % len(_FREE_POOL)]
-    _pool_idx += 1
-    return model
+MODEL_MAP = {
+    "claude-sonnet-4-6": "deepseek-v4-flash-free",
+    "claude-sonnet-4-5": "deepseek-v4-flash-free",
 
+    "claude-haiku-4-6": "minimax-m2.5-free",
+    "claude-haiku-4-5": "qwen3.6-plus-free",
+    "claude-haiku-4-5-20251001": "deepseek-v4-flash-free",
 
-MODEL_MAP = {
-    # Claude models -> round-robin free pool (resolved at request time)
-    "claude-sonnet-4-6":         None,
-    "claude-sonnet-4-5":         None,
-    "claude-haiku-4-6":          None,
-    "claude-haiku-4-5":          None,
-    "claude-haiku-4-5-20251001": None,
-    "claude-opus-4-6":           "nemotron-3-super-free",
-    # Direct aliases
-    "deepseek-v4-flash-free":    "deepseek-v4-flash-free",
-    "nemotron-3-super-free":     "nemotron-3-super-free",
-    "qwen3.6-plus-free":         "qwen3.6-plus-free",
-    "minimax-m2.5-free":         "minimax-m2.5-free",
-    "big-pickle":                "big-pickle",
+    "claude-opus-4-6": "nemotron-3-super-free",
 }
 
 DEFAULT_MODEL = "deepseek-v4-flash-free"
@@ -88,174 +84,113 @@ _MODELS_CACHE = {
     "object": "list",
     "data": [
         {
-            "id": m,
+            "id": model,
             "object": "model",
             "created": 1710000000,
             "owned_by": "gateway"
         }
-        for m in MODEL_MAP
+        for model in MODEL_MAP
     ],
 }
 
 # =========================================================
-# BROWSER TOOLS — strip before sending to DeepSeek
+# FASTAPI
 # =========================================================
 
-_BROWSER_TOOLS = {
-    "list_connected_browsers", "tabs_context_mcp",
-    "browser_action", "screenshot", "puppeteer",
-    "open_browser", "web_browser", "navigate",
-    "click", "type_text", "get_page_content",
-    "scroll", "wait_for_element",
-}
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+
+    app.state.client = httpx.AsyncClient(
+        http2=False,
+
+        timeout=httpx.Timeout(
+            connect=20,
+            read=300,
+            write=60,
+            pool=60
+        ),
+
+        limits=httpx.Limits(
+            max_connections=100,
+            max_keepalive_connections=20
+        ),
+
+        follow_redirects=True,
+    )
+
+    logger.info("Gateway started.")
+
+    yield
+
+    await app.state.client.aclose()
+
+
+app = FastAPI(lifespan=lifespan)
 
 # =========================================================
-# THINK-TAG PARSER
-# Parses <think>…</think> tags from streaming text.
-# Some models wrap reasoning in tags instead of a field.
-# Ported from github.com/Alishahryar1/free-claude-code
+# ROOT
 # =========================================================
 
-class _ThinkParser:
+@app.get("/")
+@app.head("/")
+async def root():
 
-    OPEN  = "<think>"
-    CLOSE = "</think>"
+    return {
+        "status": "ok",
+        "service": "OpenCode Gateway"
+    }
 
-    def __init__(self):
-        self._buf = ""
-        self._in  = False
 
-    def feed(self, text):
-        """Yield (is_thinking, chunk) tuples."""
-        self._buf += text
-        while self._buf:
-            prev = len(self._buf)
-            result = self._step()
-            if result is not None:
-                yield result
-            elif len(self._buf) == prev:
-                break
+@app.get("/health")
+async def health():
 
-    def flush(self):
-        if self._buf:
-            yield (self._in, self._buf)
-            self._buf = ""
-
-    def _step(self):
-        if self._in:
-            return self._inside()
-        return self._outside()
-
-    def _outside(self):
-        o = self._buf.find(self.OPEN)
-        c = self._buf.find(self.CLOSE)
-
-        # orphan close tag
-        if c != -1 and (o == -1 or c < o):
-            pre = self._buf[:c]
-            self._buf = self._buf[c + len(self.CLOSE):]
-            return (False, pre) if pre else None
-
-        if o == -1:
-            br = self._buf.rfind("<")
-            if br != -1:
-                tail = self._buf[br:]
-                if (
-                    len(tail) < len(self.OPEN)
-                    and self.OPEN.startswith(tail)
-                ):
-                    emit = self._buf[:br]
-                    self._buf = self._buf[br:]
-                    return (False, emit) if emit else None
-            emit = self._buf
-            self._buf = ""
-            return (False, emit) if emit else None
-
-        pre = self._buf[:o]
-        self._buf = self._buf[o + len(self.OPEN):]
-        self._in = True
-        return (False, pre) if pre else None
-
-    def _inside(self):
-        c = self._buf.find(self.CLOSE)
-        if c == -1:
-            br = self._buf.rfind("<")
-            if br != -1:
-                tail = self._buf[br:]
-                if (
-                    len(tail) < len(self.CLOSE)
-                    and self.CLOSE.startswith(tail)
-                ):
-                    emit = self._buf[:br]
-                    self._buf = self._buf[br:]
-                    return (True, emit) if emit else None
-            emit = self._buf
-            self._buf = ""
-            return (True, emit) if emit else None
-
-        thinking = self._buf[:c]
-        self._buf = self._buf[c + len(self.CLOSE):]
-        self._in = False
-        return (True, thinking) if thinking else None
-
-# =========================================================
-# SCHEMA FIX  (DeepSeek rejects type:null)
-# =========================================================
-
-_VALID_TYPES = {
-    "object", "array", "string",
-    "number", "boolean", "integer",
-}
+    return {
+        "status": "healthy"
+    }
+
+
+@app.get("/v1/models")
+async def get_models():
+
+    return _MODELS_CACHE
+
+# =========================================================
+# FIX TOOL SCHEMA
+# =========================================================
 
+_VALID_SCHEMA_TYPES = {
+    "object",
+    "array",
+    "string",
+    "number",
+    "boolean",
+    "integer"
+}
 
 def _fix_schema(schema):
+
     if not isinstance(schema, dict):
-        return {"type": "object", "properties": {}}
-    if schema.get("type") not in _VALID_TYPES:
-        schema = dict(schema)
-        schema["type"] = "object"
-        schema.setdefault("properties", {})
-    return schema
-
-# =========================================================
-# REASONING EXTRACTION
-# Reads thinking back from previous assistant messages so
-# DeepSeek receives reasoning_content on the next turn.
-# =========================================================
-
-def _extract_reasoning(msg):
-    rc = msg.get("reasoning_content")
-    if isinstance(rc, str) and rc:
-        return rc
-    content = msg.get("content", "")
-    if isinstance(content, list):
-        parts = [
-            item.get("thinking", "")
-            for item in content
-            if isinstance(item, dict)
-            and item.get("type") == "thinking"
-        ]
-        joined = "".join(parts)
-        if joined:
-            return joined
-    return None
-
-# =========================================================
-# SYSTEM HELPER
-# =========================================================
-
-def _system_to_str(raw):
-    if isinstance(raw, str):
-        return raw or ""
-    if isinstance(raw, list):
-        return "\n".join(
-            item.get("text", "") if isinstance(item, dict) else str(item)
-            for item in raw
-        )
-    return ""
+
+        return {
+            "type": "object",
+            "properties": {}
+        }
+
+    fixed = dict(schema)
+
+    if fixed.get("type") not in _VALID_SCHEMA_TYPES:
+
+        fixed["type"] = "object"
+
+    if fixed["type"] == "object":
+
+        fixed.setdefault("properties", {})
+
+    return fixed
 
 # =========================================================
 # NORMALIZE MESSAGES
+# Anthropic -> OpenAI
 # =========================================================
 
 def normalize_messages(messages):
@@ -264,98 +199,202 @@ def normalize_messages(messages):
 
     for msg in messages:
 
-        role    = msg.get("role", "user")
+        role = msg.get("role", "user")
+
         content = msg.get("content", "")
 
+        # -------------------------------------------------
+        # STRING CONTENT
+        # -------------------------------------------------
+
         if isinstance(content, str):
-            entry = {"role": role, "content": content}
-            if role == "assistant":
-                rc = _extract_reasoning(msg)
-                if rc:
-                    entry["reasoning_content"] = rc
-            output.append(entry)
+
+            clean_msg = {
+                "role": role,
+                "content": content
+            }
+
+            # pass reasoning_content through
+            if msg.get("reasoning_content"):
+
+                clean_msg["reasoning_content"] = (
+                    msg["reasoning_content"]
+                )
+
+            output.append(clean_msg)
+
             continue
 
+        # -------------------------------------------------
+        # ARRAY CONTENT
+        # -------------------------------------------------
+
         if isinstance(content, list):
 
-            text_parts   = []
-            tool_calls   = []
+            text_parts = []
+
+            tool_calls = []
+
             tool_results = []
 
             for item in content:
 
                 if not isinstance(item, dict):
+
                     text_parts.append(str(item))
+
                     continue
 
-                t = item.get("type", "")
+                item_type = item.get("type", "")
+
+                # -----------------------------------------
+                # TEXT
+                # -----------------------------------------
+
+                if item_type == "text":
 
-                if t == "text":
                     txt = item.get("text", "")
+
                     if txt:
+
                         text_parts.append(txt)
 
-                elif t == "thinking":
-                    pass  # recovered via _extract_reasoning
+                # -----------------------------------------
+                # TOOL USE
+                # -----------------------------------------
+
+                elif item_type == "tool_use":
 
-                elif t == "tool_use":
                     tool_calls.append({
-                        "id":   item.get(
-                            "id", f"call_{uuid.uuid4().hex[:8]}"
+
+                        "id": item.get(
+                            "id",
+                            f"call_{uuid.uuid4().hex[:8]}"
                         ),
+
                         "type": "function",
+
                         "function": {
-                            "name": item.get("name", ""),
+
+                            "name": item.get(
+                                "name",
+                                ""
+                            ),
+
                             "arguments": json.dumps(
                                 item.get("input", {})
                             ),
                         },
                     })
 
-                elif t == "tool_result":
-                    rc_c = item.get("content", "")
-                    if isinstance(rc_c, list):
-                        rc_c = "\n".join(
+                # -----------------------------------------
+                # TOOL RESULT
+                # -----------------------------------------
+
+                elif item_type == "tool_result":
+
+                    rc = item.get("content", "")
+
+                    if isinstance(rc, list):
+
+                        rc = "\n".join(
                             c.get("text", "")
-                            if isinstance(c, dict) else str(c)
-                            for c in rc_c
+                            if isinstance(c, dict)
+                            else str(c)
+                            for c in rc
                         )
+
                     tool_results.append({
-                        "role":         "tool",
-                        "tool_call_id": item.get("tool_use_id", ""),
-                        "content":      str(rc_c),
+
+                        "role": "tool",
+
+                        "tool_call_id": item.get(
+                            "tool_use_id",
+                            ""
+                        ),
+
+                        "content": str(rc),
                     })
 
+            # ---------------------------------------------
+            # ASSISTANT WITH TOOLS
+            # ---------------------------------------------
+
             if tool_calls:
-                am = {
-                    "role":       "assistant",
+
+                assistant_msg = {
+
+                    "role": "assistant",
+
                     "tool_calls": tool_calls,
+
                     "content": (
-                        "\n".join(text_parts) if text_parts else None
-                    ),
+                        "\n".join(text_parts)
+                        if text_parts
+                        else None
+                    )
                 }
-                rc = _extract_reasoning(msg)
-                if rc:
-                    am["reasoning_content"] = rc
-                output.append(am)
+
+                # IMPORTANT:
+                # pass reasoning_content through
+
+                if msg.get("reasoning_content"):
+
+                    assistant_msg["reasoning_content"] = (
+                        msg["reasoning_content"]
+                    )
+
+                output.append(assistant_msg)
+
+            # ---------------------------------------------
+            # TOOL RESULTS
+            # ---------------------------------------------
 
             elif tool_results:
+
                 output.extend(tool_results)
 
+            # ---------------------------------------------
+            # NORMAL ARRAY MESSAGE
+            # ---------------------------------------------
+
             else:
-                entry = {
-                    "role":    role,
-                    "content": "\n".join(text_parts),
+
+                normal_msg = {
+
+                    "role": role,
+
+                    "content": "\n".join(text_parts)
                 }
-                if role == "assistant":
-                    rc = _extract_reasoning(msg)
-                    if rc:
-                        entry["reasoning_content"] = rc
-                output.append(entry)
+
+                if msg.get("reasoning_content"):
+
+                    normal_msg["reasoning_content"] = (
+                        msg["reasoning_content"]
+                    )
+
+                output.append(normal_msg)
 
             continue
 
-        output.append({"role": role, "content": str(content)})
+        # -------------------------------------------------
+        # FALLBACK
+        # -------------------------------------------------
+
+        fallback_msg = {
+
+            "role": role,
+
+            "content": str(content)
+        }
+
+        if msg.get("reasoning_content"):
+
+            fallback_msg["reasoning_content"] = (
+                msg["reasoning_content"]
+            )
+
+        output.append(fallback_msg)
 
     return output
 
@@ -363,487 +402,746 @@ def normalize_messages(messages):
 # TOOLS
 # =========================================================
 
-def _filter_tools(tools):
-    filtered = []
-    removed  = []
-    for t in tools:
-        name = t.get("name", "") if isinstance(t, dict) else ""
-        if name in _BROWSER_TOOLS:
-            removed.append(name)
-        else:
-            filtered.append(t)
-    if removed:
-        logger.info("Stripped browser tools: %s", removed)
-    return filtered
+def convert_tools_to_openai(tools):
 
+    if not tools:
+        return []
 
-def convert_tools(tools):
     result = []
-    for t in tools:
+
+    for tool in tools:
+
+        fixed_schema = _fix_schema(
+            tool.get("input_schema", {})
+        )
+
         result.append({
+
             "type": "function",
+
             "function": {
-                "name":        t.get("name", ""),
-                "description": t.get("description", ""),
-                "parameters":  _fix_schema(t.get("input_schema", {})),
+
+                "name": tool.get(
+                    "name",
+                    ""
+                ),
+
+                "description": tool.get(
+                    "description",
+                    ""
+                ),
+
+                "parameters": fixed_schema,
             },
         })
+
     return result
 
+# =========================================================
+# TOOL CHOICE
+# =========================================================
+
+_TOOL_CHOICE_ANY = "required"
+
+def map_tool_choice(
+    tool_choice_raw,
+    has_tools
+):
+
+    if not tool_choice_raw or not has_tools:
 
-def map_tool_choice(raw, has_tools):
-    if not raw or not has_tools:
         return None
-    if isinstance(raw, dict):
-        t = raw.get("type", "auto")
-        if t == "any":
-            return "required"
-        if t == "tool":
+
+    if isinstance(tool_choice_raw, dict):
+
+        tool_type = tool_choice_raw.get(
+            "type",
+            "auto"
+        )
+
+        if tool_type == "any":
+
+            return _TOOL_CHOICE_ANY
+
+        if tool_type == "tool":
+
             return {
+
                 "type": "function",
-                "function": {"name": raw.get("name", "")}
+
+                "function": {
+                    "name": tool_choice_raw.get(
+                        "name",
+                        ""
+                    )
+                }
             }
-        return t
-    return raw
+
+        return tool_type
+
+    return tool_choice_raw
 
 # =========================================================
-# CONVERT NORMAL RESPONSE
+# BUILD PAYLOAD
 # =========================================================
 
-_FINISH_MAP = {"tool_calls": "tool_use", "length": "max_tokens"}
+def build_payload(
+    body,
+    openai_messages,
+    openai_tools,
+    openai_tool_choice,
+    mapped_model,
+    stream
+):
 
+    payload = {
 
-def convert_response(parsed, model):
+        "model": mapped_model,
 
-    blocks      = []
-    stop_reason = "end_turn"
+        "messages": openai_messages,
 
-    try:
-        choices = parsed.get("choices") or []
-        if choices:
-            choice      = choices[0]
-            message     = choice.get("message", {})
-            stop_reason = _FINISH_MAP.get(
-                choice.get("finish_reason"), "end_turn"
-            )
+        "temperature": body.get(
+            "temperature",
+            0.7
+        ),
 
-            reasoning = message.get("reasoning_content", "")
-            if reasoning:
-                blocks.append({"type": "thinking", "thinking": reasoning})
+        "max_tokens": min(
+            body.get("max_tokens", 32000),
+            64000
+        ),
 
-            text = message.get("content") or ""
-            if text:
-                blocks.append({"type": "text", "text": text})
+        "stream": stream,
+    }
 
-            for tc in message.get("tool_calls") or []:
-                fn       = tc.get("function", {})
-                raw_args = fn.get("arguments", "{}")
-                try:
-                    args = json.loads(raw_args)
-                except Exception:
-                    args = {"raw": raw_args}
-                blocks.append({
-                    "type":  "tool_use",
-                    "id":    tc.get("id", f"toolu_{uuid.uuid4().hex[:8]}"),
-                    "name":  fn.get("name", ""),
-                    "input": args,
-                })
+    if openai_tools:
 
-    except Exception as err:
-        logger.warning("convert_response: %s", err)
+        payload["tools"] = openai_tools
 
-    if not blocks:
-        blocks.append({"type": "text", "text": ""})
+        if openai_tool_choice is not None:
 
-    usage = parsed.get("usage", {})
-    return {
-        "id":            f"msg_{uuid.uuid4().hex}",
-        "type":          "message",
-        "role":          "assistant",
-        "model":         model,
-        "content":       blocks,
-        "stop_reason":   stop_reason,
-        "stop_sequence": None,
-        "usage": {
-            "input_tokens":  usage.get("prompt_tokens", 0),
-            "output_tokens": usage.get("completion_tokens", 0),
-        },
-    }
+            payload["tool_choice"] = (
+                openai_tool_choice
+            )
+
+    return payload
 
 # =========================================================
-# STREAM CONVERTER
+# CONVERT NORMAL RESPONSE
+# OpenAI -> Anthropic
 # =========================================================
 
-_E_MSG_START   = "event: message_start\ndata: "
-_E_BLOCK_START = "event: content_block_start\ndata: "
-_E_BLOCK_DELTA = "event: content_block_delta\ndata: "
-_E_BLOCK_STOP  = "event: content_block_stop\ndata: "
-_E_MSG_DELTA   = "event: message_delta\ndata: "
-_E_MSG_STOP    = "event: message_stop\ndata: "
+_FINISH_MAP = {
+    "tool_calls": "tool_use",
+    "length": "max_tokens"
+}
 
+def convert_to_anthropic(
+    parsed,
+    requested_model
+):
 
-async def stream_convert(response, model):
+    content_blocks = []
 
-    msg_id      = f"msg_{uuid.uuid4().hex}"
-    out_tokens  = 0
     stop_reason = "end_turn"
 
-    thinking_idx = None
-    text_idx     = None
-    tool_idx     = {}
-    tool_state   = {}
-    next_idx     = 0
+    reasoning_content = ""
 
-    parser = _ThinkParser()
+    try:
 
-    # message_start
-    yield (
-        _E_MSG_START
-        + json.dumps({
-            "type": "message_start",
-            "message": {
-                "id": msg_id, "type": "message",
-                "role": "assistant", "model": model,
-                "content": [], "stop_reason": None,
-                "stop_sequence": None,
-                "usage": {"input_tokens": 0, "output_tokens": 0},
-            },
-        })
-        + "\n\n"
-    )
-    yield 'event: ping\ndata: {"type":"ping"}\n\n'
-
-    # helpers
-
-    def open_thinking():
-        nonlocal thinking_idx, next_idx
-        thinking_idx = next_idx
-        next_idx += 1
-        return (
-            _E_BLOCK_START
-            + json.dumps({
-                "type": "content_block_start",
-                "index": thinking_idx,
-                "content_block": {"type": "thinking", "thinking": ""},
-            })
-            + "\n\n"
-        )
+        choices = parsed.get("choices")
 
-    def delta_thinking(text):
-        return (
-            _E_BLOCK_DELTA
-            + json.dumps({
-                "type": "content_block_delta",
-                "index": thinking_idx,
-                "delta": {"type": "thinking_delta", "thinking": text},
-            })
-            + "\n\n"
-        )
+        if choices:
 
-    def open_text():
-        nonlocal text_idx, next_idx
-        text_idx  = next_idx
-        next_idx += 1
-        return (
-            _E_BLOCK_START
-            + json.dumps({
-                "type": "content_block_start",
-                "index": text_idx,
-                "content_block": {"type": "text", "text": ""},
-            })
-            + "\n\n"
-        )
+            choice = choices[0]
 
-    def delta_text(text):
-        return (
-            _E_BLOCK_DELTA
-            + json.dumps({
-                "type": "content_block_delta",
-                "index": text_idx,
-                "delta": {"type": "text_delta", "text": text},
-            })
-            + "\n\n"
-        )
+            message = choice.get(
+                "message",
+                {}
+            )
 
-    try:
+            stop_reason = _FINISH_MAP.get(
+                choice.get("finish_reason"),
+                "end_turn"
+            )
 
-        async for raw in response.aiter_lines():
+            text = (
+                message.get("content")
+                or ""
+            )
 
-            if not raw or not raw.startswith("data:"):
-                continue
+            reasoning_content = (
+                message.get("reasoning_content")
+                or message.get("reasoning")
+                or ""
+            )
 
-            line = raw[5:].strip()
+            if text:
 
-            if line == "[DONE]":
-                break
+                content_blocks.append({
 
-            try:
-                chunk = json.loads(line)
-            except Exception:
-                continue
+                    "type": "text",
 
-            if chunk.get("usage"):
-                out_tokens = chunk["usage"].get(
-                    "completion_tokens", out_tokens
+                    "text": text
+                })
+
+            for tc in (
+                message.get("tool_calls")
+                or []
+            ):
+
+                fn = tc.get(
+                    "function",
+                    {}
                 )
 
-            choices = chunk.get("choices")
-            if not choices:
-                continue
+                raw_args = fn.get(
+                    "arguments",
+                    "{}"
+                )
 
-            choice = choices[0]
-            delta  = choice.get("delta", {})
-            finish = choice.get("finish_reason")
+                try:
 
-            if finish == "tool_calls":
-                stop_reason = "tool_use"
-            elif finish == "length":
-                stop_reason = "max_tokens"
+                    parsed_args = json.loads(
+                        raw_args
+                    )
 
-            # reasoning_content field (DeepSeek native)
-            rc = delta.get("reasoning_content")
-            if rc:
-                if thinking_idx is None:
-                    yield open_thinking()
-                yield delta_thinking(rc)
-                continue
+                except Exception:
 
-            # text content — may contain <think> tags
-            raw_text = delta.get("content") or ""
-            if raw_text:
-                for is_thinking, chunk_text in parser.feed(raw_text):
-                    if is_thinking:
-                        if thinking_idx is None:
-                            yield open_thinking()
-                        yield delta_thinking(chunk_text)
-                    else:
-                        if text_idx is None:
-                            yield open_text()
-                        yield delta_text(chunk_text)
-
-            # tool calls
-            for tc in delta.get("tool_calls") or []:
-                idx = tc.get("index", 0)
-
-                if idx not in tool_state:
-                    tool_state[idx] = {
-                        "id":   tc.get(
-                            "id", f"toolu_{uuid.uuid4().hex[:8]}"
-                        ),
-                        "name": "",
+                    parsed_args = {
+                        "raw": raw_args
                     }
-                    blk = next_idx
-                    next_idx += 1
-                    tool_idx[idx] = blk
-                    fn_name = (tc.get("function") or {}).get("name", "")
-                    tool_state[idx]["name"] = fn_name
-                    yield (
-                        _E_BLOCK_START
-                        + json.dumps({
-                            "type": "content_block_start",
-                            "index": blk,
-                            "content_block": {
-                                "type":  "tool_use",
-                                "id":    tool_state[idx]["id"],
-                                "name":  fn_name,
-                                "input": {},
-                            },
-                        })
-                        + "\n\n"
-                    )
 
-                args = (tc.get("function") or {}).get("arguments", "")
-                if args:
-                    yield (
-                        _E_BLOCK_DELTA
-                        + json.dumps({
-                            "type":  "content_block_delta",
-                            "index": tool_idx[idx],
-                            "delta": {
-                                "type":         "input_json_delta",
-                                "partial_json": args,
-                            },
-                        })
-                        + "\n\n"
-                    )
+                content_blocks.append({
 
-    except Exception as err:
-        logger.warning("stream error: %s", err)
-
-    # flush leftover think-tag buffer
-    for is_thinking, chunk_text in (parser.flush() or []):
-        if is_thinking:
-            if thinking_idx is None:
-                yield open_thinking()
-            yield delta_thinking(chunk_text)
-        else:
-            if text_idx is None:
-                yield open_text()
-            yield delta_text(chunk_text)
-
-    # close blocks
-    if thinking_idx is not None:
-        yield (
-            _E_BLOCK_STOP
-            + json.dumps({
-                "type": "content_block_stop",
-                "index": thinking_idx,
-            })
-            + "\n\n"
-        )
+                    "type": "tool_use",
 
-    if text_idx is not None:
-        yield (
-            _E_BLOCK_STOP
-            + json.dumps({
-                "type": "content_block_stop",
-                "index": text_idx,
-            })
-            + "\n\n"
-        )
+                    "id": tc.get(
+                        "id",
+                        f"toolu_{uuid.uuid4().hex[:8]}"
+                    ),
 
-    for _, blk in tool_idx.items():
-        yield (
-            _E_BLOCK_STOP
-            + json.dumps({
-                "type": "content_block_stop",
-                "index": blk,
-            })
-            + "\n\n"
+                    "name": fn.get(
+                        "name",
+                        ""
+                    ),
+
+                    "input": parsed_args,
+                })
+
+    except Exception as error:
+
+        logger.warning(
+            "convert error: %s",
+            error
         )
 
-    yield (
-        _E_MSG_DELTA
-        + json.dumps({
-            "type": "message_delta",
-            "delta": {
-                "stop_reason":   stop_reason,
-                "stop_sequence": None,
-            },
-            "usage": {"output_tokens": out_tokens},
+    if not content_blocks:
+
+        content_blocks.append({
+
+            "type": "text",
+
+            "text": ""
         })
-        + "\n\n"
-    )
 
-    yield (
-        _E_MSG_STOP
-        + json.dumps({"type": "message_stop"})
-        + "\n\n"
+    usage = parsed.get(
+        "usage",
+        {}
     )
 
-# =========================================================
-# CONNECTOR PROMPT
-# =========================================================
-# Teaches the model which tools it has and forces it to use
-# them — this is what makes it behave like real Claude with
-# connectors (web search, file system, MCP tools etc.)
+    response = {
 
-def _build_connector_prompt(tools):
-    if not tools:
-        return ""
+        "id": f"msg_{uuid.uuid4().hex}",
 
-    names = {t.get("name", "") for t in tools if isinstance(t, dict)}
+        "type": "message",
 
-    sections = []
+        "role": "assistant",
 
-    # Web search
-    web = {
-        "web_search", "search", "brave_search",
-        "tavily_search", "web_search_tool",
-    }
-    if names & web:
-        sections.append(
-            "- WEB SEARCH available: call it immediately whenever the user"
-            " asks about current events, news, prices, docs, or any"
-            " real-time information. Never say you cannot search."
-        )
+        "model": requested_model,
 
-    # File system
-    fs = {
-        "read_file", "write_file", "create_file",
-        "edit_file", "list_directory", "list_files",
-        "str_replace_editor", "view_file",
+        "content": content_blocks,
+
+        "stop_reason": stop_reason,
+
+        "stop_sequence": None,
+
+        "usage": {
+
+            "input_tokens": usage.get(
+                "prompt_tokens",
+                0
+            ),
+
+            "output_tokens": usage.get(
+                "completion_tokens",
+                0
+            ),
+        },
     }
-    if names & fs:
-        sections.append(
-            "- FILE SYSTEM available: read, write and create files on disk."
-            " When asked for a document, CSV, JSON or any file — create it."
+
+    # IMPORTANT:
+    # preserve reasoning_content
+
+    if reasoning_content:
+
+        response["reasoning_content"] = (
+            reasoning_content
         )
 
-    # Code execution
-    exe = {
-        "execute_command", "run_command", "bash",
-        "shell", "terminal", "execute_code",
+    return response
+
+# =========================================================
+# STREAM CONSTANTS
+# =========================================================
+
+_STREAM_MSG_START   = "event: message_start\ndata: "
+_STREAM_BLOCK_START = "event: content_block_start\ndata: "
+_STREAM_BLOCK_DELTA = "event: content_block_delta\ndata: "
+_STREAM_BLOCK_STOP  = "event: content_block_stop\ndata: "
+_STREAM_MSG_DELTA   = "event: message_delta\ndata: "
+_STREAM_MSG_STOP    = "event: message_stop\ndata: "
+
+# =========================================================
+# STREAM CONVERSION
+# OpenAI SSE -> Anthropic SSE
+# =========================================================
+
+async def convert_stream_to_anthropic(
+    response,
+    requested_model
+):
+
+    msg_id = f"msg_{uuid.uuid4().hex}"
+
+    input_tokens = 0
+    output_tokens = 0
+
+    reasoning_parts = []
+
+    start_payload = {
+
+        "type": "message_start",
+
+        "message": {
+
+            "id": msg_id,
+
+            "type": "message",
+
+            "role": "assistant",
+
+            "model": requested_model,
+
+            "content": [],
+
+            "reasoning_content": "",
+
+            "stop_reason": None,
+
+            "stop_sequence": None,
+
+            "usage": {
+
+                "input_tokens": 0,
+
+                "output_tokens": 0,
+            },
+        },
     }
-    if names & exe:
-        sections.append(
-            "- CODE EXECUTION available: run shell commands directly."
-            " Use it to install packages, run scripts, or test code."
+
+    yield (
+        f"{_STREAM_MSG_START}"
+        f"{json.dumps(start_payload)}"
+        "\n\n"
+    )
+
+    yield (
+        'event: ping\ndata: {"type":"ping"}\n\n'
+    )
+
+    tool_state = {}
+
+    tool_block_idx = {}
+
+    text_block_idx = None
+
+    next_idx = 0
+
+    stop_reason = "end_turn"
+
+    try:
+
+        async for raw in response.aiter_lines():
+
+            if (
+                not raw
+                or not raw.startswith("data:")
+            ):
+                continue
+
+            line = raw[5:].strip()
+
+            if line == "[DONE]":
+                break
+
+            try:
+
+                chunk = json.loads(line)
+
+            except Exception:
+
+                continue
+
+            # -------------------------------------------------
+            # USAGE
+            # -------------------------------------------------
+
+            if chunk.get("usage"):
+
+                usage = chunk["usage"]
+
+                input_tokens = usage.get(
+                    "prompt_tokens",
+                    input_tokens
+                )
+
+                output_tokens = usage.get(
+                    "completion_tokens",
+                    output_tokens
+                )
+
+            choices = chunk.get("choices")
+
+            if not choices:
+                continue
+
+            choice = choices[0]
+
+            delta = choice.get(
+                "delta",
+                {}
+            )
+
+            finish_reason = choice.get(
+                "finish_reason"
+            )
+
+            # -------------------------------------------------
+            # REASONING DELTA
+            # -------------------------------------------------
+
+            reasoning_delta = (
+                delta.get("reasoning_content")
+                or delta.get("reasoning")
+                or ""
+            )
+
+            if reasoning_delta:
+
+                reasoning_parts.append(
+                    reasoning_delta
+                )
+
+            # -------------------------------------------------
+            # STOP REASON
+            # -------------------------------------------------
+
+            if finish_reason == "tool_calls":
+
+                stop_reason = "tool_use"
+
+            elif finish_reason == "length":
+
+                stop_reason = "max_tokens"
+
+            # -------------------------------------------------
+            # TEXT DELTA
+            # -------------------------------------------------
+
+            text_delta = delta.get(
+                "content"
+            )
+
+            if text_delta:
+
+                if text_block_idx is None:
+
+                    text_block_idx = next_idx
+
+                    next_idx += 1
+
+                    block_payload = {
+
+                        "type": "content_block_start",
+
+                        "index": text_block_idx,
+
+                        "content_block": {
+
+                            "type": "text",
+
+                            "text": ""
+                        }
+                    }
+
+                    yield (
+                        f"{_STREAM_BLOCK_START}"
+                        f"{json.dumps(block_payload)}"
+                        "\n\n"
+                    )
+
+                delta_payload = {
+
+                    "type": "content_block_delta",
+
+                    "index": text_block_idx,
+
+                    "delta": {
+
+                        "type": "text_delta",
+
+                        "text": text_delta
+                    }
+                }
+
+                yield (
+                    f"{_STREAM_BLOCK_DELTA}"
+                    f"{json.dumps(delta_payload)}"
+                    "\n\n"
+                )
+
+            # -------------------------------------------------
+            # TOOL CALLS
+            # -------------------------------------------------
+
+            tool_call_deltas = delta.get(
+                "tool_calls"
+            )
+
+            if tool_call_deltas:
+
+                for tc_delta in tool_call_deltas:
+
+                    idx = tc_delta.get(
+                        "index",
+                        0
+                    )
+
+                    if idx not in tool_state:
+
+                        tool_state[idx] = {
+
+                            "id": tc_delta.get(
+                                "id",
+                                f"toolu_{uuid.uuid4().hex[:8]}"
+                            ),
+
+                            "name": "",
+
+                            "args": "",
+                        }
+
+                        block_index = next_idx
+
+                        next_idx += 1
+
+                        tool_block_idx[idx] = (
+                            block_index
+                        )
+
+                        fn = tc_delta.get(
+                            "function",
+                            {}
+                        )
+
+                        tool_state[idx]["name"] = (
+                            fn.get("name", "")
+                        )
+
+                        block_payload = {
+
+                            "type": "content_block_start",
+
+                            "index": block_index,
+
+                            "content_block": {
+
+                                "type": "tool_use",
+
+                                "id": tool_state[idx]["id"],
+
+                                "name": tool_state[idx]["name"],
+
+                                "input": {}
+                            }
+                        }
+
+                        yield (
+                            f"{_STREAM_BLOCK_START}"
+                            f"{json.dumps(block_payload)}"
+                            "\n\n"
+                        )
+
+                    fn = tc_delta.get(
+                        "function",
+                        {}
+                    )
+
+                    if fn.get("name"):
+
+                        tool_state[idx]["name"] += (
+                            fn["name"]
+                        )
+
+                    args = fn.get(
+                        "arguments",
+                        ""
+                    )
+
+                    if args:
+
+                        tool_state[idx]["args"] += (
+                            args
+                        )
+
+                        block_index = (
+                            tool_block_idx[idx]
+                        )
+
+                        delta_payload = {
+
+                            "type": "content_block_delta",
+
+                            "index": block_index,
+
+                            "delta": {
+
+                                "type": "input_json_delta",
+
+                                "partial_json": args
+                            }
+                        }
+
+                        yield (
+                            f"{_STREAM_BLOCK_DELTA}"
+                            f"{json.dumps(delta_payload)}"
+                            "\n\n"
+                        )
+
+    except Exception as error:
+
+        logger.warning(
+            "stream error: %s",
+            error
         )
 
-    # MCP / other tools
-    known = web | fs | exe | _BROWSER_TOOLS | {""}
-    other = sorted(names - known)
-    if other:
-        sections.append(
-            "- ADDITIONAL TOOLS: " + ", ".join(other) + "."
-            " Use them whenever they are the most direct solution."
+    # =====================================================
+    # CLOSE TEXT BLOCK
+    # =====================================================
+
+    if text_block_idx is not None:
+
+        close_payload = {
+
+            "type": "content_block_stop",
+
+            "index": text_block_idx
+        }
+
+        yield (
+            f"{_STREAM_BLOCK_STOP}"
+            f"{json.dumps(close_payload)}"
+            "\n\n"
         )
 
-    if not sections:
-        return ""
+    # =====================================================
+    # CLOSE TOOL BLOCKS
+    # =====================================================
 
-    lines = [
-        "# Connector capabilities active in this session",
-        "",
-        "You have real tools connected. Use them proactively:",
-        "",
-    ] + sections + [
-        "",
-        "IMPORTANT: always call the relevant tool instead of saying"
-        " you cannot access external information.",
-    ]
+    for _, block_index in tool_block_idx.items():
 
-    return "\n".join(lines)
+        close_payload = {
 
+            "type": "content_block_stop",
 
-# =========================================================
-# FASTAPI
-# =========================================================
+            "index": block_index
+        }
 
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    app.state.client = httpx.AsyncClient(
-        http2=False,
-        timeout=httpx.Timeout(connect=20, read=300, write=60, pool=60),
-        limits=httpx.Limits(
-            max_connections=100,
-            max_keepalive_connections=20,
-        ),
-        follow_redirects=True,
+        yield (
+            f"{_STREAM_BLOCK_STOP}"
+            f"{json.dumps(close_payload)}"
+            "\n\n"
+        )
+
+    # =====================================================
+    # FINAL REASONING DELTA
+    # =====================================================
+
+    full_reasoning = "".join(
+        reasoning_parts
     )
-    logger.info("Gateway started.")
-    yield
-    await app.state.client.aclose()
 
+    if full_reasoning:
 
-app = FastAPI(lifespan=lifespan)
+        reasoning_payload = {
 
+            "type": "message_delta",
 
-@app.get("/")
-@app.head("/")
-async def root():
-    return {"status": "ok", "service": "OpenCode Gateway"}
+            "delta": {
 
+                "reasoning_content": (
+                    full_reasoning
+                )
+            }
+        }
 
-@app.get("/health")
-async def health():
-    return {"status": "healthy"}
+        yield (
+            f"{_STREAM_MSG_DELTA}"
+            f"{json.dumps(reasoning_payload)}"
+            "\n\n"
+        )
 
+    # =====================================================
+    # FINAL MESSAGE DELTA
+    # =====================================================
 
-@app.get("/v1/models")
-async def get_models():
-    return _MODELS_CACHE
+    delta_payload = {
+
+        "type": "message_delta",
+
+        "delta": {
+
+            "stop_reason": stop_reason,
+
+            "stop_sequence": None
+        },
+
+        "usage": {
+
+            "output_tokens": output_tokens
+        }
+    }
+
+    yield (
+        f"{_STREAM_MSG_DELTA}"
+        f"{json.dumps(delta_payload)}"
+        "\n\n"
+    )
+
+    # =====================================================
+    # STOP
+    # =====================================================
+
+    stop_payload = {
+
+        "type": "message_stop"
+    }
+
+    yield (
+        f"{_STREAM_MSG_STOP}"
+        f"{json.dumps(stop_payload)}"
+        "\n\n"
+    )
 
 # =========================================================
 # MAIN ENDPOINT
@@ -853,142 +1151,334 @@ async def get_models():
 @app.post("/v1/chat/completions")
 async def messages(
     request: Request,
-    authorization: str = Header(default=None),
+    authorization: str = Header(default=None)
 ):
-    req_id = uuid.uuid4().hex[:8]
+
+    request_id = uuid.uuid4().hex[:8]
+
+    # =====================================================
+    # API KEY
+    # =====================================================
 
     if not OPENCODE_API_KEY:
+
         return JSONResponse(
+
             status_code=401,
-            content={"error": "Missing OPENCODE_API_KEY"},
+
+            content={
+                "error": (
+                    "Missing OPENCODE_API_KEY"
+                )
+            }
         )
 
+    # =====================================================
+    # PARSE BODY
+    # =====================================================
+
     try:
+
         body = await request.json()
+
     except Exception:
+
         return JSONResponse(
+
             status_code=400,
-            content={"error": "Invalid JSON"},
+
+            content={
+                "error": "Invalid JSON"
+            }
         )
 
-    requested_model = body.get("model", "claude-sonnet-4-6")
-    _direct = MODEL_MAP.get(requested_model, DEFAULT_MODEL)
-    mapped_model = _pick_free_model() if _direct is None else _direct
-    stream          = bool(body.get("stream", False))
-
-    # tools
-    raw_tools    = body.get("tools", [])
-    clean_tools  = _filter_tools(raw_tools)
-    openai_tools = convert_tools(clean_tools)
-    tool_choice  = map_tool_choice(
-        body.get("tool_choice"), bool(openai_tools)
+    # =====================================================
+    # MODEL
+    # =====================================================
+
+    requested_model = body.get(
+        "model",
+        "claude-sonnet-4-6"
     )
 
-    # messages
-    oai_messages = normalize_messages(body.get("messages", []))
+    mapped_model = MODEL_MAP.get(
+        requested_model,
+        DEFAULT_MODEL
+    )
 
-    # system
-    sys_str      = _system_to_str(body.get("system", ""))
-    connector_str = _build_connector_prompt(clean_tools)
+    stream = bool(
+        body.get("stream", False)
+    )
 
-    parts = [p for p in [connector_str, sys_str] if p]
-    full_system = "\n\n---\n\n".join(parts)
+    # =====================================================
+    # TOOLS
+    # =====================================================
 
-    if full_system:
-        oai_messages.insert(0, {"role": "system", "content": full_system})
+    anthropic_tools = body.get(
+        "tools",
+        []
+    )
 
-    # payload
-    payload = {
-        "model":       mapped_model,
-        "messages":    oai_messages,
-        "temperature": body.get("temperature", 0.7),
-        "max_tokens":  min(body.get("max_tokens", 32000), 64000),
-        "stream":      stream,
-    }
-    if openai_tools:
-        payload["tools"] = openai_tools
-        if tool_choice is not None:
-            payload["tool_choice"] = tool_choice
+    openai_tools = convert_tools_to_openai(
+        anthropic_tools
+    )
 
-    headers = {**UPSTREAM_HEADERS, "x-api-key": OPENCODE_API_KEY}
+    openai_tool_choice = map_tool_choice(
+        body.get("tool_choice"),
+        bool(openai_tools)
+    )
+
+    # =====================================================
+    # MESSAGES
+    # =====================================================
+
+    openai_messages = normalize_messages(
+        body.get("messages", [])
+    )
+
+    system_prompt = body.get(
+        "system",
+        ""
+    )
+
+    if system_prompt:
+
+        openai_messages.insert(
+            0,
+            {
+                "role": "system",
+                "content": system_prompt
+            }
+        )
+
+    # =====================================================
+    # PAYLOAD
+    # =====================================================
+
+    payload = build_payload(
+
+        body,
+
+        openai_messages,
+
+        openai_tools,
+
+        openai_tool_choice,
+
+        mapped_model,
+
+        stream
+    )
+
+    headers = {
+
+        **UPSTREAM_HEADERS,
+
+        "x-api-key": OPENCODE_API_KEY
+    }
 
     logger.info(
+
         "[%s] %s -> %s | stream=%s | tools=%d",
-        req_id, requested_model, mapped_model,
-        stream, len(openai_tools),
+
+        request_id,
+
+        requested_model,
+
+        mapped_model,
+
+        stream,
+
+        len(openai_tools)
     )
 
-    client     = request.app.state.client
+    client = request.app.state.client
+
     last_error = None
 
-    for attempt in range(1, MAX_RETRIES + 1):
+    # =====================================================
+    # RETRIES
+    # =====================================================
+
+    for attempt in range(
+        1,
+        MAX_RETRIES + 1
+    ):
 
         try:
 
-            # ---------- STREAM ----------
+            # =================================================
+            # STREAM MODE
+            # =================================================
+
             if stream:
 
-                upstream_req = client.build_request(
-                    "POST", UPSTREAM_URL,
-                    json=payload, headers=headers,
+                upstream_request = (
+                    client.build_request(
+                        "POST",
+                        UPSTREAM_URL,
+                        json=payload,
+                        headers=headers
+                    )
+                )
+
+                response = await client.send(
+                    upstream_request,
+                    stream=True
                 )
-                resp = await client.send(upstream_req, stream=True)
 
-                if resp.status_code != 200:
-                    raw_err = (
-                        await resp.aread()
+                # ---------------------------------------------
+                # ERROR
+                # ---------------------------------------------
+
+                if response.status_code != 200:
+
+                    raw_error = (
+                        await response.aread()
                     ).decode(errors="ignore")
+
                     logger.warning(
+
                         "[%s] fail %d: %s",
-                        req_id, resp.status_code, raw_err[:200],
+
+                        request_id,
+
+                        response.status_code,
+
+                        raw_error[:200]
                     )
-                    last_error = raw_err
-                    await asyncio.sleep(RETRY_DELAY)
+
+                    last_error = raw_error
+
+                    await asyncio.sleep(
+                        RETRY_DELAY
+                    )
+
                     continue
 
+                # ---------------------------------------------
+                # SUCCESS
+                # ---------------------------------------------
+
                 return StreamingResponse(
-                    stream_convert(resp, requested_model),
+
+                    convert_stream_to_anthropic(
+                        response,
+                        requested_model
+                    ),
+
                     media_type="text/event-stream",
-                    headers=STREAM_HEADERS,
+
+                    headers=STREAM_RESPONSE_HEADERS,
                 )
 
-            # ---------- NORMAL ----------
-            resp = await client.post(
-                UPSTREAM_URL, json=payload, headers=headers,
+            # =================================================
+            # NORMAL MODE
+            # =================================================
+
+            response = await client.post(
+
+                UPSTREAM_URL,
+
+                json=payload,
+
+                headers=headers
             )
 
-            if resp.status_code != 200:
+            # -------------------------------------------------
+            # ERROR
+            # -------------------------------------------------
+
+            if response.status_code != 200:
+
                 logger.warning(
-                    "[%s] fail %d", req_id, resp.status_code
+
+                    "[%s] fail %d",
+
+                    request_id,
+
+                    response.status_code
+                )
+
+                last_error = response.text
+
+                await asyncio.sleep(
+                    RETRY_DELAY
                 )
-                last_error = resp.text
-                await asyncio.sleep(RETRY_DELAY)
+
                 continue
 
-            if not resp.text.strip():
+            raw_response = (
+                response.text.strip()
+            )
+
+            if not raw_response:
+
                 return JSONResponse(
+
                     status_code=502,
-                    content={"error": "Empty upstream response"},
+
+                    content={
+                        "error": (
+                            "Empty upstream response"
+                        )
+                    }
                 )
 
             try:
-                parsed = resp.json()
+
+                parsed_response = (
+                    response.json()
+                )
+
             except Exception:
+
                 return JSONResponse(
+
                     status_code=502,
-                    content={"error": "Invalid upstream JSON"},
+
+                    content={
+                        "error": (
+                            "Invalid upstream JSON"
+                        )
+                    }
                 )
 
             return JSONResponse(
-                content=convert_response(parsed, requested_model)
+
+                content=convert_to_anthropic(
+                    parsed_response,
+                    requested_model
+                )
             )
 
-        except Exception as err:
-            last_error = str(err)
-            logger.exception("[%s] exception", req_id)
-            await asyncio.sleep(RETRY_DELAY)
+        except Exception as error:
+
+            last_error = str(error)
+
+            logger.exception(
+
+                "[%s] exception",
+
+                request_id
+            )
+
+            await asyncio.sleep(
+                RETRY_DELAY
+            )
+
+    # =====================================================
+    # FINAL FAILURE
+    # =====================================================
 
     return JSONResponse(
+
         status_code=502,
-        content={"error": "Upstream failed", "details": last_error},
+
+        content={
+
+            "error": "Upstream failed",
+
+            "details": last_error
+        }
     )