Update app.py

app.py

@@ -1,14 +1,8 @@
-# =========================================================
-# 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
@@ -31,20 +25,13 @@ logger = logging.getLogger("OpenCodeGateway")
 # CONFIG
 # =========================================================
 
-OPENCODE_API_KEY = os.getenv(
-    "OPENCODE_API_KEY",
-    ""
-).strip()
+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",
@@ -70,15 +57,13 @@ STREAM_RESPONSE_HEADERS = {
 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-6": "deepseek-v4-flash-free",
+    "claude-haiku-4-5": "deepseek-v4-flash-free",
     "claude-haiku-4-5-20251001": "deepseek-v4-flash-free",
-
     "claude-opus-4-6": "nemotron-3-super-free",
 }
 
-DEFAULT_MODEL = "nemotron-3-super-free"
+DEFAULT_MODEL = "deepseek-v4-flash-free"
 
 _MODELS_CACHE = {
     "object": "list",
@@ -102,19 +87,16 @@ 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,
     )
 
@@ -128,13 +110,12 @@ async def lifespan(app: FastAPI):
 app = FastAPI(lifespan=lifespan)
 
 # =========================================================
-# ROOT
+# ROOT / HEALTH / MODELS
 # =========================================================
 
 @app.get("/")
 @app.head("/")
 async def root():
-
     return {
         "status": "ok",
         "service": "OpenCode Gateway"
@@ -143,7 +124,6 @@ async def root():
 
 @app.get("/health")
 async def health():
-
     return {
         "status": "healthy"
     }
@@ -151,47 +131,30 @@ async def health():
 
 @app.get("/v1/models")
 async def get_models():
-
     return _MODELS_CACHE
 
 # =========================================================
 # FIX TOOL SCHEMA
 # =========================================================
-
-_VALID_SCHEMA_TYPES = {
-    "object",
-    "array",
-    "string",
-    "number",
-    "boolean",
-    "integer"
-}
+# DeepSeek rejects tools whose input_schema has type=null.
+# We patch any schema that is missing a valid "type" field
+# to be type=object so the provider accepts it.
 
 def _fix_schema(schema):
-
+    """Ensure schema has type=object at root (DeepSeek requirement)."""
     if not isinstance(schema, dict):
-
-        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
+        return {"type": "object", "properties": {}}
+    if schema.get("type") not in ("object", "array", "string", "number", "boolean", "integer"):
+        schema = dict(schema)
+        schema["type"] = "object"
+        schema.setdefault("properties", {})
+    return schema
 
 # =========================================================
 # NORMALIZE MESSAGES
-# Anthropic -> OpenAI
 # =========================================================
+# Also strips `reasoning_content` from assistant messages
+# (DeepSeek thinking mode artifact that must not be echoed back).
 
 def normalize_messages(messages):
 
@@ -200,7 +163,6 @@ def normalize_messages(messages):
     for msg in messages:
 
         role = msg.get("role", "user")
-
         content = msg.get("content", "")
 
         # -------------------------------------------------
@@ -209,40 +171,27 @@ def normalize_messages(messages):
 
         if isinstance(content, str):
 
-            clean_msg = {
+            output.append({
                 "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
+        # LIST CONTENT
         # -------------------------------------------------
 
         if isinstance(content, list):
 
             text_parts = []
-
             tool_calls = []
-
             tool_results = []
 
             for item in content:
 
                 if not isinstance(item, dict):
-
                     text_parts.append(str(item))
-
                     continue
 
                 item_type = item.get("type", "")
@@ -256,7 +205,6 @@ def normalize_messages(messages):
                     txt = item.get("text", "")
 
                     if txt:
-
                         text_parts.append(txt)
 
                 # -----------------------------------------
@@ -266,21 +214,13 @@ def normalize_messages(messages):
                 elif item_type == "tool_use":
 
                     tool_calls.append({
-
                         "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", {})
                             ),
@@ -305,29 +245,23 @@ def normalize_messages(messages):
                         )
 
                     tool_results.append({
-
                         "role": "tool",
-
                         "tool_call_id": item.get(
                             "tool_use_id",
                             ""
                         ),
-
                         "content": str(rc),
                     })
 
             # ---------------------------------------------
-            # ASSISTANT WITH TOOLS
+            # FINALIZE MESSAGE
             # ---------------------------------------------
 
             if tool_calls:
 
                 assistant_msg = {
-
                     "role": "assistant",
-
                     "tool_calls": tool_calls,
-
                     "content": (
                         "\n".join(text_parts)
                         if text_parts
@@ -335,45 +269,18 @@ def normalize_messages(messages):
                     )
                 }
 
-                # 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:
 
-                normal_msg = {
-
+                output.append({
                     "role": role,
-
                     "content": "\n".join(text_parts)
-                }
-
-                if msg.get("reasoning_content"):
-
-                    normal_msg["reasoning_content"] = (
-                        msg["reasoning_content"]
-                    )
-
-                output.append(normal_msg)
+                })
 
             continue
 
@@ -381,22 +288,28 @@ def normalize_messages(messages):
         # FALLBACK
         # -------------------------------------------------
 
-        fallback_msg = {
-
+        output.append({
             "role": role,
-
             "content": str(content)
-        }
+        })
 
-        if msg.get("reasoning_content"):
+    # -----------------------------------------------------
+    # STRIP reasoning_content FROM EVERY ASSISTANT MESSAGE
+    # -----------------------------------------------------
+    # DeepSeek thinking mode puts reasoning_content in the
+    # response. If it gets echoed back in the next turn,
+    # DeepSeek returns 400. We remove it unconditionally.
 
-            fallback_msg["reasoning_content"] = (
-                msg["reasoning_content"]
-            )
+    clean = []
+
+    for msg in output:
 
-        output.append(fallback_msg)
+        if msg.get("role") == "assistant" and "reasoning_content" in msg:
+            msg = {k: v for k, v in msg.items() if k != "reasoning_content"}
 
-    return output
+        clean.append(msg)
+
+    return clean
 
 # =========================================================
 # TOOLS
@@ -411,27 +324,14 @@ def convert_tools_to_openai(tools):
 
     for tool in tools:
 
-        fixed_schema = _fix_schema(
-            tool.get("input_schema", {})
-        )
+        schema = _fix_schema(tool.get("input_schema", {}))
 
         result.append({
-
             "type": "function",
-
             "function": {
-
-                "name": tool.get(
-                    "name",
-                    ""
-                ),
-
-                "description": tool.get(
-                    "description",
-                    ""
-                ),
-
-                "parameters": fixed_schema,
+                "name": tool.get("name", ""),
+                "description": tool.get("description", ""),
+                "parameters": schema,
             },
         })
 
@@ -443,37 +343,24 @@ def convert_tools_to_openai(tools):
 
 _TOOL_CHOICE_ANY = "required"
 
-def map_tool_choice(
-    tool_choice_raw,
-    has_tools
-):
+def map_tool_choice(tool_choice_raw, has_tools):
 
     if not tool_choice_raw or not has_tools:
-
         return None
 
     if isinstance(tool_choice_raw, dict):
 
-        tool_type = tool_choice_raw.get(
-            "type",
-            "auto"
-        )
+        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": tool_choice_raw.get(
-                        "name",
-                        ""
-                    )
+                    "name": tool_choice_raw.get("name", "")
                 }
             }
 
@@ -495,21 +382,13 @@ def build_payload(
 ):
 
     payload = {
-
         "model": mapped_model,
-
         "messages": openai_messages,
-
-        "temperature": body.get(
-            "temperature",
-            0.7
-        ),
-
+        "temperature": body.get("temperature", 0.7),
         "max_tokens": min(
             body.get("max_tokens", 32000),
             64000
         ),
-
         "stream": stream,
     }
 
@@ -518,16 +397,12 @@ def build_payload(
         payload["tools"] = openai_tools
 
         if openai_tool_choice is not None:
-
-            payload["tool_choice"] = (
-                openai_tool_choice
-            )
+            payload["tool_choice"] = openai_tool_choice
 
     return payload
 
 # =========================================================
 # CONVERT NORMAL RESPONSE
-# OpenAI -> Anthropic
 # =========================================================
 
 _FINISH_MAP = {
@@ -535,17 +410,12 @@ _FINISH_MAP = {
     "length": "max_tokens"
 }
 
-def convert_to_anthropic(
-    parsed,
-    requested_model
-):
+def convert_to_anthropic(parsed, requested_model):
 
     content_blocks = []
 
     stop_reason = "end_turn"
 
-    reasoning_content = ""
-
     try:
 
         choices = parsed.get("choices")
@@ -554,77 +424,43 @@ def convert_to_anthropic(
 
             choice = choices[0]
 
-            message = choice.get(
-                "message",
-                {}
-            )
+            message = choice.get("message", {})
 
             stop_reason = _FINISH_MAP.get(
                 choice.get("finish_reason"),
                 "end_turn"
             )
 
-            text = (
-                message.get("content")
-                or ""
-            )
-
-            reasoning_content = (
-                message.get("reasoning_content")
-                or message.get("reasoning")
-                or ""
-            )
+            text = message.get("content") or ""
 
             if text:
 
                 content_blocks.append({
-
                     "type": "text",
-
                     "text": text
                 })
 
-            for tc in (
-                message.get("tool_calls")
-                or []
-            ):
+            for tc in (message.get("tool_calls") or []):
 
-                fn = tc.get(
-                    "function",
-                    {}
-                )
+                fn = tc.get("function", {})
 
-                raw_args = fn.get(
-                    "arguments",
-                    "{}"
-                )
+                raw_args = fn.get("arguments", "{}")
 
                 try:
-
-                    parsed_args = json.loads(
-                        raw_args
-                    )
+                    parsed_args = json.loads(raw_args)
 
                 except Exception:
-
                     parsed_args = {
                         "raw": raw_args
                     }
 
                 content_blocks.append({
-
                     "type": "tool_use",
-
                     "id": tc.get(
                         "id",
                         f"toolu_{uuid.uuid4().hex[:8]}"
                     ),
-
-                    "name": fn.get(
-                        "name",
-                        ""
-                    ),
-
+                    "name": fn.get("name", ""),
                     "input": parsed_args,
                 })
 
@@ -638,40 +474,25 @@ def convert_to_anthropic(
     if not content_blocks:
 
         content_blocks.append({
-
             "type": "text",
-
             "text": ""
         })
 
-    usage = parsed.get(
-        "usage",
-        {}
-    )
-
-    response = {
+    usage = parsed.get("usage", {})
 
+    return {
         "id": f"msg_{uuid.uuid4().hex}",
-
         "type": "message",
-
         "role": "assistant",
-
         "model": requested_model,
-
         "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
@@ -679,19 +500,8 @@ def convert_to_anthropic(
         },
     }
 
-    # IMPORTANT:
-    # preserve reasoning_content
-
-    if reasoning_content:
-
-        response["reasoning_content"] = (
-            reasoning_content
-        )
-
-    return response
-
 # =========================================================
-# STREAM CONSTANTS
+# STREAM CONVERSION
 # =========================================================
 
 _STREAM_MSG_START   = "event: message_start\ndata: "
@@ -701,11 +511,6 @@ _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
@@ -716,34 +521,18 @@ async def convert_stream_to_anthropic(
     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,
             },
         },
@@ -755,12 +544,9 @@ async def convert_stream_to_anthropic(
         "\n\n"
     )
 
-    yield (
-        'event: ping\ndata: {"type":"ping"}\n\n'
-    )
+    yield 'event: ping\ndata: {"type":"ping"}\n\n'
 
     tool_state = {}
-
     tool_block_idx = {}
 
     text_block_idx = None
@@ -773,10 +559,7 @@ async def convert_stream_to_anthropic(
 
         async for raw in response.aiter_lines():
 
-            if (
-                not raw
-                or not raw.startswith("data:")
-            ):
+            if not raw or not raw.startswith("data:"):
                 continue
 
             line = raw[5:].strip()
@@ -785,17 +568,11 @@ async def convert_stream_to_anthropic(
                 break
 
             try:
-
                 chunk = json.loads(line)
 
             except Exception:
-
                 continue
 
-            # -------------------------------------------------
-            # USAGE
-            # -------------------------------------------------
-
             if chunk.get("usage"):
 
                 usage = chunk["usage"]
@@ -817,69 +594,35 @@ async def convert_stream_to_anthropic(
 
             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:
+            delta = choice.get("delta", {})
 
-                reasoning_parts.append(
-                    reasoning_delta
-                )
-
-            # -------------------------------------------------
-            # STOP REASON
-            # -------------------------------------------------
+            finish_reason = choice.get("finish_reason")
 
             if finish_reason == "tool_calls":
-
                 stop_reason = "tool_use"
 
             elif finish_reason == "length":
-
                 stop_reason = "max_tokens"
 
             # -------------------------------------------------
             # TEXT DELTA
+            # Skip reasoning_content keys at stream level too
             # -------------------------------------------------
 
-            text_delta = delta.get(
-                "content"
-            )
+            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": ""
                         }
                     }
@@ -891,15 +634,10 @@ async def convert_stream_to_anthropic(
                     )
 
                 delta_payload = {
-
                     "type": "content_block_delta",
-
                     "index": text_block_idx,
-
                     "delta": {
-
                         "type": "text_delta",
-
                         "text": text_delta
                     }
                 }
@@ -914,64 +652,44 @@ async def convert_stream_to_anthropic(
             # TOOL CALLS
             # -------------------------------------------------
 
-            tool_call_deltas = delta.get(
-                "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
-                    )
+                    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
-                        )
+                        tool_block_idx[idx] = block_index
 
-                        fn = tc_delta.get(
-                            "function",
-                            {}
-                        )
+                        fn = tc_delta.get("function", {})
 
-                        tool_state[idx]["name"] = (
-                            fn.get("name", "")
+                        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": {}
                             }
                         }
@@ -982,42 +700,25 @@ async def convert_stream_to_anthropic(
                             "\n\n"
                         )
 
-                    fn = tc_delta.get(
-                        "function",
-                        {}
-                    )
+                    fn = tc_delta.get("function", {})
 
                     if fn.get("name"):
 
-                        tool_state[idx]["name"] += (
-                            fn["name"]
-                        )
+                        tool_state[idx]["name"] += fn["name"]
 
-                    args = fn.get(
-                        "arguments",
-                        ""
-                    )
+                    args = fn.get("arguments", "")
 
                     if args:
 
-                        tool_state[idx]["args"] += (
-                            args
-                        )
+                        tool_state[idx]["args"] += args
 
-                        block_index = (
-                            tool_block_idx[idx]
-                        )
+                        block_index = tool_block_idx[idx]
 
                         delta_payload = {
-
                             "type": "content_block_delta",
-
                             "index": block_index,
-
                             "delta": {
-
                                 "type": "input_json_delta",
-
                                 "partial_json": args
                             }
                         }
@@ -1035,16 +736,14 @@ async def convert_stream_to_anthropic(
             error
         )
 
-    # =====================================================
-    # CLOSE TEXT BLOCK
-    # =====================================================
+    # ---------------------------------------------------------
+    # CLOSE BLOCKS
+    # ---------------------------------------------------------
 
     if text_block_idx is not None:
 
         close_payload = {
-
             "type": "content_block_stop",
-
             "index": text_block_idx
         }
 
@@ -1054,16 +753,10 @@ async def convert_stream_to_anthropic(
             "\n\n"
         )
 
-    # =====================================================
-    # CLOSE TOOL BLOCKS
-    # =====================================================
-
     for _, block_index in tool_block_idx.items():
 
         close_payload = {
-
             "type": "content_block_stop",
-
             "index": block_index
         }
 
@@ -1073,51 +766,13 @@ async def convert_stream_to_anthropic(
             "\n\n"
         )
 
-    # =====================================================
-    # FINAL REASONING DELTA
-    # =====================================================
-
-    full_reasoning = "".join(
-        reasoning_parts
-    )
-
-    if full_reasoning:
-
-        reasoning_payload = {
-
-            "type": "message_delta",
-
-            "delta": {
-
-                "reasoning_content": (
-                    full_reasoning
-                )
-            }
-        }
-
-        yield (
-            f"{_STREAM_MSG_DELTA}"
-            f"{json.dumps(reasoning_payload)}"
-            "\n\n"
-        )
-
-    # =====================================================
-    # FINAL MESSAGE DELTA
-    # =====================================================
-
     delta_payload = {
-
         "type": "message_delta",
-
         "delta": {
-
             "stop_reason": stop_reason,
-
             "stop_sequence": None
         },
-
         "usage": {
-
             "output_tokens": output_tokens
         }
     }
@@ -1128,12 +783,7 @@ async def convert_stream_to_anthropic(
         "\n\n"
     )
 
-    # =====================================================
-    # STOP
-    # =====================================================
-
     stop_payload = {
-
         "type": "message_stop"
     }
 
@@ -1156,27 +806,15 @@ async def messages(
 
     request_id = uuid.uuid4().hex[:8]
 
-    # =====================================================
-    # API KEY
-    # =====================================================
-
     if not OPENCODE_API_KEY:
 
         return JSONResponse(
-
             status_code=401,
-
             content={
-                "error": (
-                    "Missing OPENCODE_API_KEY"
-                )
+                "error": "Missing OPENCODE_API_KEY"
             }
         )
 
-    # =====================================================
-    # PARSE BODY
-    # =====================================================
-
     try:
 
         body = await request.json()
@@ -1184,18 +822,12 @@ async def messages(
     except Exception:
 
         return JSONResponse(
-
             status_code=400,
-
             content={
                 "error": "Invalid JSON"
             }
         )
 
-    # =====================================================
-    # MODEL
-    # =====================================================
-
     requested_model = body.get(
         "model",
         "claude-sonnet-4-6"
@@ -1210,14 +842,11 @@ async def messages(
         body.get("stream", False)
     )
 
-    # =====================================================
+    # ---------------------------------------------------------
     # TOOLS
-    # =====================================================
+    # ---------------------------------------------------------
 
-    anthropic_tools = body.get(
-        "tools",
-        []
-    )
+    anthropic_tools = body.get("tools", [])
 
     openai_tools = convert_tools_to_openai(
         anthropic_tools
@@ -1228,18 +857,15 @@ async def messages(
         bool(openai_tools)
     )
 
-    # =====================================================
+    # ---------------------------------------------------------
     # MESSAGES
-    # =====================================================
+    # ---------------------------------------------------------
 
     openai_messages = normalize_messages(
         body.get("messages", [])
     )
 
-    system_prompt = body.get(
-        "system",
-        ""
-    )
+    system_prompt = body.get("system", "")
 
     if system_prompt:
 
@@ -1251,44 +877,30 @@ async def messages(
             }
         )
 
-    # =====================================================
+    # ---------------------------------------------------------
     # 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",
-
         request_id,
-
         requested_model,
-
         mapped_model,
-
         stream,
-
         len(openai_tools)
     )
 
@@ -1296,30 +908,25 @@ async def messages(
 
     last_error = None
 
-    # =====================================================
+    # =========================================================
     # RETRIES
-    # =====================================================
+    # =========================================================
 
-    for attempt in range(
-        1,
-        MAX_RETRIES + 1
-    ):
+    for attempt in range(1, MAX_RETRIES + 1):
 
         try:
 
-            # =================================================
+            # -------------------------------------------------
             # STREAM MODE
-            # =================================================
+            # -------------------------------------------------
 
             if stream:
 
-                upstream_request = (
-                    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(
@@ -1327,10 +934,6 @@ async def messages(
                     stream=True
                 )
 
-                # ---------------------------------------------
-                # ERROR
-                # ---------------------------------------------
-
                 if response.status_code != 200:
 
                     raw_error = (
@@ -1338,114 +941,76 @@ async def messages(
                     ).decode(errors="ignore")
 
                     logger.warning(
-
                         "[%s] fail %d: %s",
-
                         request_id,
-
                         response.status_code,
-
                         raw_error[:200]
                     )
 
                     last_error = raw_error
 
-                    await asyncio.sleep(
-                        RETRY_DELAY
-                    )
+                    await asyncio.sleep(RETRY_DELAY)
 
                     continue
 
-                # ---------------------------------------------
-                # SUCCESS
-                # ---------------------------------------------
-
                 return StreamingResponse(
-
                     convert_stream_to_anthropic(
                         response,
                         requested_model
                     ),
-
                     media_type="text/event-stream",
-
                     headers=STREAM_RESPONSE_HEADERS,
                 )
 
-            # =================================================
+            # -------------------------------------------------
             # NORMAL MODE
-            # =================================================
+            # -------------------------------------------------
 
             response = await client.post(
-
                 UPSTREAM_URL,
-
                 json=payload,
-
                 headers=headers
             )
 
-            # -------------------------------------------------
-            # ERROR
-            # -------------------------------------------------
-
             if response.status_code != 200:
 
                 logger.warning(
-
                     "[%s] fail %d",
-
                     request_id,
-
                     response.status_code
                 )
 
                 last_error = response.text
 
-                await asyncio.sleep(
-                    RETRY_DELAY
-                )
+                await asyncio.sleep(RETRY_DELAY)
 
                 continue
 
-            raw_response = (
-                response.text.strip()
-            )
+            raw_response = response.text.strip()
 
             if not raw_response:
 
                 return JSONResponse(
-
                     status_code=502,
-
                     content={
-                        "error": (
-                            "Empty upstream response"
-                        )
+                        "error": "Empty upstream response"
                     }
                 )
 
             try:
 
-                parsed_response = (
-                    response.json()
-                )
+                parsed_response = response.json()
 
             except Exception:
 
                 return JSONResponse(
-
                     status_code=502,
-
                     content={
-                        "error": (
-                            "Invalid upstream JSON"
-                        )
+                        "error": "Invalid upstream JSON"
                     }
                 )
 
             return JSONResponse(
-
                 content=convert_to_anthropic(
                     parsed_response,
                     requested_model
@@ -1457,28 +1022,16 @@ async def messages(
             last_error = str(error)
 
             logger.exception(
-
                 "[%s] exception",
-
                 request_id
             )
 
-            await asyncio.sleep(
-                RETRY_DELAY
-            )
-
-    # =====================================================
-    # FINAL FAILURE
-    # =====================================================
+            await asyncio.sleep(RETRY_DELAY)
 
     return JSONResponse(
-
         status_code=502,
-
         content={
-
             "error": "Upstream failed",
-
             "details": last_error
         }
     )