Update app.py

app.py

@@ -136,6 +136,9 @@ async def get_models():
 # =========================================================
 # FIX TOOL SCHEMA
 # =========================================================
+# 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)."""
@@ -150,94 +153,162 @@ def _fix_schema(schema):
 # =========================================================
 # NORMALIZE MESSAGES
 # =========================================================
+# DeepSeek requires `reasoning_content` to be passed back in the
+# message history if it was generated in a previous turn.
 
 def normalize_messages(messages):
 
     output = []
 
     for msg in messages:
+
         role = msg.get("role", "user")
         content = msg.get("content", "")
-
-        # الاحتفاظ بـ reasoning_content إذا كان موجوداً في الرسالة الأصلية القادمة من الـ History
-        reasoning = msg.get("reasoning_content")
+        reasoning_content = msg.get("reasoning_content")
 
         # -------------------------------------------------
         # STRING CONTENT
         # -------------------------------------------------
+
         if isinstance(content, str):
-            base_msg = {"role": role, "content": content}
-            if reasoning:
-                base_msg["reasoning_content"] = reasoning
-            output.append(base_msg)
+            new_msg = {
+                "role": role,
+                "content": content
+            }
+            if role == "assistant" and reasoning_content:
+                new_msg["reasoning_content"] = reasoning_content
+            output.append(new_msg)
             continue
 
         # -------------------------------------------------
         # 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", "")
 
+                # -----------------------------------------
+                # TEXT
+                # -----------------------------------------
+
                 if item_type == "text":
+
                     txt = item.get("text", "")
+
                     if txt:
                         text_parts.append(txt)
 
+                # -----------------------------------------
+                # TOOL USE
+                # -----------------------------------------
+
                 elif item_type == "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", ""),
-                            "arguments": json.dumps(item.get("input", {})),
+                            "arguments": json.dumps(
+                                item.get("input", {})
+                            ),
                         },
                     })
 
+                # -----------------------------------------
+                # 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)
+                            c.get("text", "")
+                            if isinstance(c, dict)
+                            else str(c)
                             for c in rc
                         )
+
                     tool_results.append({
                         "role": "tool",
-                        "tool_call_id": item.get("tool_use_id", ""),
+                        "tool_call_id": item.get(
+                            "tool_use_id",
+                            ""
+                        ),
                         "content": str(rc),
                     })
 
+            # ---------------------------------------------
+            # FINALIZE MESSAGE
+            # ---------------------------------------------
+
             if tool_calls:
+
                 assistant_msg = {
                     "role": "assistant",
                     "tool_calls": tool_calls,
-                    "content": "\n".join(text_parts) if text_parts else None
+                    "content": (
+                        "\n".join(text_parts)
+                        if text_parts
+                        else None
+                    )
                 }
-                if reasoning:
-                    assistant_msg["reasoning_content"] = reasoning
+                if reasoning_content:
+                    assistant_msg["reasoning_content"] = reasoning_content
+
                 output.append(assistant_msg)
+
             elif tool_results:
+
                 output.extend(tool_results)
+
             else:
-                final_msg = {"role": role, "content": "\n".join(text_parts)}
-                if reasoning:
-                    final_msg["reasoning_content"] = reasoning
-                output.append(final_msg)
+
+                new_msg = {
+                    "role": role,
+                    "content": "\n".join(text_parts)
+                }
+                if role == "assistant" and reasoning_content:
+                    new_msg["reasoning_content"] = reasoning_content
+                output.append(new_msg)
+
             continue
 
-        fallback_msg = {"role": role, "content": str(content)}
-        if reasoning:
-            fallback_msg["reasoning_content"] = reasoning
-        output.append(fallback_msg)
+        # -------------------------------------------------
+        # FALLBACK
+        # -------------------------------------------------
 
+        new_msg = {
+            "role": role,
+            "content": str(content)
+        }
+        if role == "assistant" and reasoning_content:
+            new_msg["reasoning_content"] = reasoning_content
+        output.append(new_msg)
+
+    # -----------------------------------------------------
+    # NO LONGER STRIP reasoning_content
+    # -----------------------------------------------------
+    # DeepSeek requires reasoning_content to be passed back
+    # in the message history when using thinking mode.
+    
     return output
 
 # =========================================================
@@ -245,11 +316,16 @@ def normalize_messages(messages):
 # =========================================================
 
 def convert_tools_to_openai(tools):
+
     if not tools:
         return []
+
     result = []
+
     for tool in tools:
+
         schema = _fix_schema(tool.get("input_schema", {}))
+
         result.append({
             "type": "function",
             "function": {
@@ -258,6 +334,7 @@ def convert_tools_to_openai(tools):
                 "parameters": schema,
             },
         })
+
     return result
 
 # =========================================================
@@ -267,38 +344,61 @@ def convert_tools_to_openai(tools):
 _TOOL_CHOICE_ANY = "required"
 
 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")
+
         if tool_type == "any":
             return _TOOL_CHOICE_ANY
+
         if tool_type == "tool":
+
             return {
                 "type": "function",
                 "function": {
                     "name": tool_choice_raw.get("name", "")
                 }
             }
+
         return tool_type
+
     return tool_choice_raw
 
 # =========================================================
 # BUILD PAYLOAD
 # =========================================================
 
-def build_payload(body, openai_messages, openai_tools, openai_tool_choice, mapped_model, stream):
+def build_payload(
+    body,
+    openai_messages,
+    openai_tools,
+    openai_tool_choice,
+    mapped_model,
+    stream
+):
+
     payload = {
         "model": mapped_model,
         "messages": openai_messages,
         "temperature": body.get("temperature", 0.7),
-        "max_tokens": min(body.get("max_tokens", 32000), 64000),
+        "max_tokens": min(
+            body.get("max_tokens", 32000),
+            64000
+        ),
         "stream": stream,
     }
+
     if openai_tools:
+
         payload["tools"] = openai_tools
+
         if openai_tool_choice is not None:
             payload["tool_choice"] = openai_tool_choice
+
     return payload
 
 # =========================================================
@@ -311,44 +411,80 @@ _FINISH_MAP = {
 }
 
 def convert_to_anthropic(parsed, requested_model):
+
     content_blocks = []
+
     stop_reason = "end_turn"
+    reasoning_content = None
+
     try:
+
         choices = parsed.get("choices")
+
         if choices:
+
             choice = choices[0]
+
             message = choice.get("message", {})
-            stop_reason = _FINISH_MAP.get(choice.get("finish_reason"), "end_turn")
+            
+            # Capture reasoning_content from DeepSeek response
+            reasoning_content = message.get("reasoning_content")
+
+            stop_reason = _FINISH_MAP.get(
+                choice.get("finish_reason"),
+                "end_turn"
+            )
+
             text = message.get("content") or ""
+
             if text:
+
                 content_blocks.append({
                     "type": "text",
                     "text": text
                 })
+
             for tc in (message.get("tool_calls") or []):
+
                 fn = tc.get("function", {})
+
                 raw_args = fn.get("arguments", "{}")
+
                 try:
                     parsed_args = json.loads(raw_args)
+
                 except Exception:
-                    parsed_args = {"raw": raw_args}
+                    parsed_args = {
+                        "raw": raw_args
+                    }
+
                 content_blocks.append({
                     "type": "tool_use",
-                    "id": tc.get("id", f"toolu_{uuid.uuid4().hex[:8]}"),
+                    "id": tc.get(
+                        "id",
+                        f"toolu_{uuid.uuid4().hex[:8]}"
+                    ),
                     "name": fn.get("name", ""),
                     "input": parsed_args,
                 })
+
     except Exception as error:
-        logger.warning("convert error: %s", error)
+
+        logger.warning(
+            "convert error: %s",
+            error
+        )
 
     if not content_blocks:
+
         content_blocks.append({
             "type": "text",
             "text": ""
         })
 
     usage = parsed.get("usage", {})
-    return {
+
+    response_obj = {
         "id": f"msg_{uuid.uuid4().hex}",
         "type": "message",
         "role": "assistant",
@@ -357,10 +493,22 @@ def convert_to_anthropic(parsed, requested_model):
         "stop_reason": stop_reason,
         "stop_sequence": None,
         "usage": {
-            "input_tokens": usage.get("prompt_tokens", 0),
-            "output_tokens": usage.get("completion_tokens", 0),
+            "input_tokens": usage.get(
+                "prompt_tokens",
+                0
+            ),
+            "output_tokens": usage.get(
+                "completion_tokens",
+                0
+            ),
         },
     }
+    
+    # Pass reasoning_content back to the client (Cline/Cursor)
+    if reasoning_content:
+        response_obj["reasoning_content"] = reasoning_content
+
+    return response_obj
 
 # =========================================================
 # STREAM CONVERSION
@@ -373,10 +521,16 @@ _STREAM_BLOCK_STOP  = "event: content_block_stop\ndata: "
 _STREAM_MSG_DELTA   = "event: message_delta\ndata: "
 _STREAM_MSG_STOP    = "event: message_stop\ndata: "
 
-async def convert_stream_to_anthropic(response, requested_model):
+async def convert_stream_to_anthropic(
+    response,
+    requested_model
+):
+
     msg_id = f"msg_{uuid.uuid4().hex}"
+
     input_tokens = 0
     output_tokens = 0
+    reasoning_content = ""
 
     start_payload = {
         "type": "message_start",
@@ -395,86 +549,154 @@ async def convert_stream_to_anthropic(response, requested_model):
         },
     }
 
-    yield f"{_STREAM_MSG_START}{json.dumps(start_payload)}\n\n"
+    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
 
             if chunk.get("usage"):
+
                 usage = chunk["usage"]
-                input_tokens = usage.get("prompt_tokens", input_tokens)
-                output_tokens = usage.get("completion_tokens", output_tokens)
+
+                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", {})
 
-            # تخطي حقول الـ reasoning_content حتى لا نرسلها لمنصة كلود كورك كـ نص
-            if "reasoning_content" in delta and not delta.get("content"):
-                continue
+            delta = choice.get("delta", {})
 
             finish_reason = choice.get("finish_reason")
+
             if finish_reason == "tool_calls":
                 stop_reason = "tool_use"
+
             elif finish_reason == "length":
                 stop_reason = "max_tokens"
+                
+            # Collect reasoning_content from stream chunks
+            reasoning_delta = delta.get("reasoning_content")
+            if reasoning_delta:
+                reasoning_content += reasoning_delta
+
+            # -------------------------------------------------
+            # 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": ""}
+                        "content_block": {
+                            "type": "text",
+                            "text": ""
+                        }
                     }
-                    yield f"{_STREAM_BLOCK_START}{json.dumps(block_payload)}\n\n"
+
+                    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}
+                    "delta": {
+                        "type": "text_delta",
+                        "text": text_delta
+                    }
                 }
-                yield f"{_STREAM_BLOCK_DELTA}{json.dumps(delta_payload)}\n\n"
+
+                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]}"),
+                            "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", "")
+
+                        tool_state[idx]["name"] = fn.get(
+                            "name",
+                            ""
+                        )
 
                         block_payload = {
                             "type": "content_block_start",
@@ -486,75 +708,197 @@ async def convert_stream_to_anthropic(response, requested_model):
                                 "input": {}
                             }
                         }
-                        yield f"{_STREAM_BLOCK_START}{json.dumps(block_payload)}\n\n"
+
+                        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}
+                            "delta": {
+                                "type": "input_json_delta",
+                                "partial_json": args
+                            }
                         }
-                        yield f"{_STREAM_BLOCK_DELTA}{json.dumps(delta_payload)}\n\n"
+
+                        yield (
+                            f"{_STREAM_BLOCK_DELTA}"
+                            f"{json.dumps(delta_payload)}"
+                            "\n\n"
+                        )
 
     except Exception as error:
-        logger.warning("stream error: %s", error)
+
+        logger.warning(
+            "stream error: %s",
+            error
+        )
+
+    # ---------------------------------------------------------
+    # CLOSE BLOCKS
+    # ---------------------------------------------------------
 
     if text_block_idx is not None:
-        close_payload = {"type": "content_block_stop", "index": text_block_idx}
-        yield f"{_STREAM_BLOCK_STOP}{json.dumps(close_payload)}\n\n"
+
+        close_payload = {
+            "type": "content_block_stop",
+            "index": text_block_idx
+        }
+
+        yield (
+            f"{_STREAM_BLOCK_STOP}"
+            f"{json.dumps(close_payload)}"
+            "\n\n"
+        )
 
     for _, block_index in tool_block_idx.items():
-        close_payload = {"type": "content_block_stop", "index": block_index}
-        yield f"{_STREAM_BLOCK_STOP}{json.dumps(close_payload)}\n\n"
 
-    stop_payload = {
+        close_payload = {
+            "type": "content_block_stop",
+            "index": block_index
+        }
+
+        yield (
+            f"{_STREAM_BLOCK_STOP}"
+            f"{json.dumps(close_payload)}"
+            "\n\n"
+        )
+
+    delta_payload = {
         "type": "message_delta",
-        "delta": {"stop_reason": stop_reason, "stop_sequence": None},
-        "usage": {"output_tokens": output_tokens}
+        "delta": {
+            "stop_reason": stop_reason,
+            "stop_sequence": None
+        },
+        "usage": {
+            "output_tokens": output_tokens
+        }
     }
-    yield f"{_STREAM_MSG_DELTA}{json.dumps(stop_payload)}\n\n"
+    
+    # Pass reasoning_content back to the client in stream mode
+    if reasoning_content:
+        delta_payload["reasoning_content"] = reasoning_content
+
+    yield (
+        f"{_STREAM_MSG_DELTA}"
+        f"{json.dumps(delta_payload)}"
+        "\n\n"
+    )
 
-    final_payload = {"type": "message_stop"}
-    yield f"{_STREAM_MSG_STOP}{json.dumps(final_payload)}\n\n"
+    stop_payload = {
+        "type": "message_stop"
+    }
+
+    yield (
+        f"{_STREAM_MSG_STOP}"
+        f"{json.dumps(stop_payload)}"
+        "\n\n"
+    )
 
 # =========================================================
-# CHAT COMPLETIONS ENDPOINT
+# MAIN ENDPOINT
 # =========================================================
 
 @app.post("/v1/messages")
-async def chat_completions(
+@app.post("/v1/chat/completions")
+async def messages(
     request: Request,
-    authorization: str = Header(None)
+    authorization: str = Header(default=None)
 ):
+
+    request_id = uuid.uuid4().hex[:8]
+
+    if not OPENCODE_API_KEY:
+
+        return JSONResponse(
+            status_code=401,
+            content={
+                "error": "Missing OPENCODE_API_KEY"
+            }
+        )
+
     try:
+
         body = await request.json()
+
     except Exception:
-        return JSONResponse(status_code=400, content={"error": "Invalid JSON body"})
 
-    requested_model = body.get("model", "claude-sonnet-4-6")
-    mapped_model = MODEL_MAP.get(requested_model, DEFAULT_MODEL)
+        return JSONResponse(
+            status_code=400,
+            content={
+                "error": "Invalid JSON"
+            }
+        )
+
+    requested_model = body.get(
+        "model",
+        "claude-sonnet-4-6"
+    )
+
+    mapped_model = MODEL_MAP.get(
+        requested_model,
+        DEFAULT_MODEL
+    )
+
+    stream = bool(
+        body.get("stream", False)
+    )
+
+    # ---------------------------------------------------------
+    # TOOLS
+    # ---------------------------------------------------------
+
+    anthropic_tools = body.get("tools", [])
+
+    openai_tools = convert_tools_to_openai(
+        anthropic_tools
+    )
+
+    openai_tool_choice = map_tool_choice(
+        body.get("tool_choice"),
+        bool(openai_tools)
+    )
+
+    # ---------------------------------------------------------
+    # MESSAGES
+    # ---------------------------------------------------------
+
+    openai_messages = normalize_messages(
+        body.get("messages", [])
+    )
 
-    raw_messages = body.get("messages", [])
     system_prompt = body.get("system", "")
 
-    openai_messages = normalize_messages(raw_messages)
     if system_prompt:
-        openai_messages.insert(0, {"role": "system", "content": system_prompt})
 
-    raw_tools = body.get("tools", [])
-    openai_tools = convert_tools_to_openai(raw_tools)
-    
-    raw_tool_choice = body.get("tool_choice")
-    openai_tool_choice = map_tool_choice(raw_tool_choice, bool(openai_tools))
+        openai_messages.insert(
+            0,
+            {
+                "role": "system",
+                "content": system_prompt
+            }
+        )
 
-    stream = body.get("stream", False)
+    # ---------------------------------------------------------
+    # PAYLOAD
+    # ---------------------------------------------------------
 
     payload = build_payload(
         body,
@@ -565,50 +909,148 @@ async def chat_completions(
         stream
     )
 
-    headers = dict(UPSTREAM_HEADERS)
-    if OPENCODE_API_KEY:
-        headers["Authorization"] = f"Bearer {OPENCODE_API_KEY}"
-    elif authorization:
-        headers["Authorization"] = authorization
+    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)
+    )
 
     client = request.app.state.client
 
-    for attempt in range(MAX_RETRIES + 1):
+    last_error = None
+
+    # =========================================================
+    # RETRIES
+    # =========================================================
+
+    for attempt in range(1, MAX_RETRIES + 1):
+
         try:
+
+            # -------------------------------------------------
+            # STREAM MODE
+            # -------------------------------------------------
+
             if stream:
-                req = client.build_request("POST", UPSTREAM_URL, json=payload, headers=headers)
-                response = await client.send(req, stream=True)
-                
+
+                upstream_request = client.build_request(
+                    "POST",
+                    UPSTREAM_URL,
+                    json=payload,
+                    headers=headers
+                )
+
+                response = await client.send(
+                    upstream_request,
+                    stream=True
+                )
+
                 if response.status_code != 200:
-                    await response.aread()
-                    logger.warning(f"fail {response.status_code}: {response.text}")
-                    if attempt < MAX_RETRIES:
-                        await asyncio.sleep(RETRY_DELAY)
-                        continue
-                    return JSONResponse(status_code=502, content={"error": f"Upstream error {response.status_code}"})
-                
+
+                    raw_error = (
+                        await response.aread()
+                    ).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)
+
+                    continue
+
                 return StreamingResponse(
-                    convert_stream_to_anthropic(response, requested_model),
+                    convert_stream_to_anthropic(
+                        response,
+                        requested_model
+                    ),
                     media_type="text/event-stream",
-                    headers=STREAM_RESPONSE_HEADERS
+                    headers=STREAM_RESPONSE_HEADERS,
                 )
-            else:
-                response = await client.post(UPSTREAM_URL, json=payload, headers=headers)
-                
-                if response.status_code != 200:
-                    logger.warning(f"fail {response.status_code}: {response.text}")
-                    if attempt < MAX_RETRIES:
-                        await asyncio.sleep(RETRY_DELAY)
-                        continue
-                    return JSONResponse(status_code=502, content={"error": f"Upstream error {response.status_code}"})
-                
-                parsed = response.json()
-                anthropic_response = convert_to_anthropic(parsed, requested_model)
-                return JSONResponse(content=anthropic_response)
 
-        except Exception as e:
-            logger.error(f"Request exception: {str(e)}")
-            if attempt < MAX_RETRIES:
+            # -------------------------------------------------
+            # NORMAL MODE
+            # -------------------------------------------------
+
+            response = await client.post(
+                UPSTREAM_URL,
+                json=payload,
+                headers=headers
+            )
+
+            if response.status_code != 200:
+
+                logger.warning(
+                    "[%s] fail %d",
+                    request_id,
+                    response.status_code
+                )
+
+                last_error = response.text
+
                 await asyncio.sleep(RETRY_DELAY)
+
                 continue
-            return JSONResponse(status_code=502, content={"error": "Gateway timeout/connection issue"})
+
+            raw_response = response.text.strip()
+
+            if not raw_response:
+
+                return JSONResponse(
+                    status_code=502,
+                    content={
+                        "error": "Empty upstream response"
+                    }
+                )
+
+            try:
+
+                parsed_response = response.json()
+
+            except Exception:
+
+                return JSONResponse(
+                    status_code=502,
+                    content={
+                        "error": "Invalid upstream JSON"
+                    }
+                )
+
+            return JSONResponse(
+                content=convert_to_anthropic(
+                    parsed_response,
+                    requested_model
+                )
+            )
+
+        except Exception as error:
+
+            last_error = str(error)
+
+            logger.exception(
+                "[%s] exception",
+                request_id
+            )
+
+            await asyncio.sleep(RETRY_DELAY)
+
+    return JSONResponse(
+        status_code=502,
+        content={
+            "error": "Upstream failed",
+            "details": last_error
+        }
+    )