Update app.py

app.py

@@ -1,3 +1,8 @@
+# =========================================================
+# OPENCODE GATEWAY
+# FIXED INTERNET + MCP + ANTHROPIC FORMAT
+# =========================================================
+
 import os
 import json
 import uuid
@@ -76,6 +81,7 @@ app = FastAPI(lifespan=lifespan)
 @app.get("/")
 @app.head("/")
 async def root():
+
     return {
         "status": "ok",
         "service": "OpenCode Gateway"
@@ -83,6 +89,7 @@ async def root():
 
 @app.get("/health")
 async def health():
+
     return {
         "status": "healthy"
     }
@@ -165,9 +172,17 @@ def normalize_messages(raw_messages):
 
     for msg in raw_messages:
 
-        role = msg.get("role", "user")
-        content = msg.get("content", "")
+        role = msg.get(
+            "role",
+            "user"
+        )
 
+        content = msg.get(
+            "content",
+            ""
+        )
+
+        # Anthropic blocks
         if isinstance(content, list):
 
             text_parts = []
@@ -177,11 +192,13 @@ def normalize_messages(raw_messages):
                 if isinstance(item, dict):
 
                     if item.get("type") == "text":
+
                         text_parts.append(
                             item.get("text", "")
                         )
 
                 elif isinstance(item, str):
+
                     text_parts.append(item)
 
             content = "\n".join(text_parts)
@@ -194,7 +211,38 @@ def normalize_messages(raw_messages):
     return normalized
 
 # =========================================================
-# OPENAI -> ANTHROPIC RESPONSE
+# REMOVE CLAUDE INTERNAL TOOLS
+# =========================================================
+def clean_tools(tools):
+
+    allowed_tools = []
+
+    blocked = {
+
+        "Agent",
+        "AskUserQuestion",
+        "Edit",
+        "Glob",
+        "Grep",
+        "NotebookEdit",
+        "ExitPlanMode",
+        "Read",
+        "Write"
+    }
+
+    for tool in tools:
+
+        name = tool.get("name", "")
+
+        if name in blocked:
+            continue
+
+        allowed_tools.append(tool)
+
+    return allowed_tools
+
+# =========================================================
+# OPENAI -> ANTHROPIC
 # =========================================================
 def convert_to_anthropic_format(
     parsed,
@@ -205,7 +253,10 @@ def convert_to_anthropic_format(
 
     try:
 
-        choices = parsed.get("choices", [])
+        choices = parsed.get(
+            "choices",
+            []
+        )
 
         if choices:
 
@@ -223,18 +274,26 @@ def convert_to_anthropic_format(
         pass
 
     return {
+
         "id": f"msg_{uuid.uuid4().hex}",
+
         "type": "message",
+
         "role": "assistant",
+
         "model": requested_model,
+
         "content": [
             {
                 "type": "text",
                 "text": content_text
             }
         ],
+
         "stop_reason": "end_turn",
+
         "stop_sequence": None,
+
         "usage": {
             "input_tokens": 0,
             "output_tokens": 0
@@ -242,56 +301,71 @@ def convert_to_anthropic_format(
     }
 
 # =========================================================
-# STREAM TRANSLATOR
+# STREAM CONVERTER
 # =========================================================
-async def stream_sse_response(
+async def anthropic_stream_response(
     response,
     requested_model
 ):
 
-    try:
+    message_id = f"msg_{uuid.uuid4().hex}"
+
+    # MESSAGE START
+    yield (
+        "event: message_start\n"
+        "data: "
+        + json.dumps({
 
-        # بداية الرسالة
-        start_payload = {
             "type": "message_start",
+
             "message": {
-                "id": f"msg_{uuid.uuid4().hex}",
+
+                "id": message_id,
+
                 "type": "message",
+
                 "role": "assistant",
+
                 "model": requested_model,
+
                 "content": [],
+
                 "stop_reason": None,
+
                 "stop_sequence": None,
+
                 "usage": {
                     "input_tokens": 0,
                     "output_tokens": 0
                 }
             }
-        }
 
-        yield (
-            "event: message_start\n"
-            "data: "
-            + json.dumps(start_payload)
-            + "\n\n"
-        )
+        })
+        + "\n\n"
+    )
+
+    # CONTENT BLOCK START
+    yield (
+        "event: content_block_start\n"
+        "data: "
+        + json.dumps({
 
-        # بداية البلوك
-        block_payload = {
             "type": "content_block_start",
+
             "index": 0,
+
             "content_block": {
+
                 "type": "text",
+
                 "text": ""
             }
-        }
 
-        yield (
-            "event: content_block_start\n"
-            "data: "
-            + json.dumps(block_payload)
-            + "\n\n"
-        )
+        })
+        + "\n\n"
+    )
+
+    try:
 
         async for line in response.aiter_lines():
 
@@ -315,7 +389,10 @@ async def stream_sse_response(
             except Exception:
                 continue
 
-            choices = parsed.get("choices", [])
+            choices = parsed.get(
+                "choices",
+                []
+            )
 
             if not choices:
                 continue
@@ -333,81 +410,95 @@ async def stream_sse_response(
             if not text:
                 continue
 
-            delta_payload = {
-                "type": "content_block_delta",
-                "index": 0,
-                "delta": {
-                    "type": "text_delta",
-                    "text": text
-                }
-            }
-
+            # CONTENT DELTA
             yield (
                 "event: content_block_delta\n"
                 "data: "
-                + json.dumps(delta_payload)
+                + json.dumps({
+
+                    "type": "content_block_delta",
+
+                    "index": 0,
+
+                    "delta": {
+
+                        "type": "text_delta",
+
+                        "text": text
+                    }
+
+                })
                 + "\n\n"
             )
 
-        # نهاية البلوك
-        end_block_payload = {
-            "type": "content_block_stop",
-            "index": 0
-        }
+    except Exception as e:
+
+        logger.exception("STREAM ERROR")
 
         yield (
-            "event: content_block_stop\n"
+            "event: error\n"
             "data: "
-            + json.dumps(end_block_payload)
+            + json.dumps({
+
+                "type": "error",
+
+                "error": {
+
+                    "type": "stream_error",
+
+                    "message": str(e)
+                }
+
+            })
             + "\n\n"
         )
 
-        # دلتا الرسالة
-        delta_payload = {
+    # CONTENT STOP
+    yield (
+        "event: content_block_stop\n"
+        "data: "
+        + json.dumps({
+
+            "type": "content_block_stop",
+
+            "index": 0
+
+        })
+        + "\n\n"
+    )
+
+    # MESSAGE DELTA
+    yield (
+        "event: message_delta\n"
+        "data: "
+        + json.dumps({
+
             "type": "message_delta",
+
             "delta": {
+
                 "stop_reason": "end_turn",
+
                 "stop_sequence": None
             },
+
             "usage": {
+
                 "output_tokens": 0
             }
-        }
-
-        yield (
-            "event: message_delta\n"
-            "data: "
-            + json.dumps(delta_payload)
-            + "\n\n"
-        )
-
-        # نهاية الرسالة
-        yield (
-            "event: message_stop\n"
-            "data: {}\n\n"
-        )
 
-    except Exception as e:
-
-        logger.exception("STREAM ERROR")
-
-        error_payload = {
-            "type": "error",
-            "error": {
-                "type": "stream_error",
-                "message": str(e)
-            }
-        }
+        })
+        + "\n\n"
+    )
 
-        yield (
-            "event: error\n"
-            "data: "
-            + json.dumps(error_payload)
-            + "\n\n"
-        )
+    # MESSAGE STOP
+    yield (
+        "event: message_stop\n"
+        "data: {}\n\n"
+    )
 
 # =========================================================
-# MAIN ROUTES
+# MAIN ROUTE
 # =========================================================
 @app.post("/v1/messages")
 @app.post("/v1/chat/completions")
@@ -427,18 +518,17 @@ async def messages(
     # Bearer
     if authorization:
 
-        auth_value = authorization.strip()
-
-        if auth_value.lower().startswith("bearer "):
+        if authorization.startswith("Bearer "):
 
-            api_key = auth_value[7:].strip()
-
-        else:
-
-            api_key = auth_value.strip()
+            api_key = (
+                authorization
+                .replace("Bearer ", "")
+                .strip()
+            )
 
     # x-api-key
     if x_api_key:
+
         api_key = x_api_key.strip()
 
     if not api_key:
@@ -446,15 +536,12 @@ async def messages(
         return JSONResponse(
             status_code=401,
             content={
-                "error": {
-                    "type": "auth_error",
-                    "message": "Missing API key"
-                }
+                "error": "Missing API key"
             }
         )
 
     # =====================================================
-    # JSON BODY
+    # BODY
     # =====================================================
     try:
 
@@ -500,13 +587,18 @@ async def messages(
     # PAYLOAD
     # =====================================================
     payload = {
+
         "model": mapped_model,
+
         "messages": normalized_messages,
+
         "stream": stream,
+
         "temperature": body.get(
             "temperature",
             0.7
         ),
+
         "max_tokens": min(
             body.get("max_tokens", 4096),
             4096
@@ -514,27 +606,39 @@ async def messages(
     }
 
     # =====================================================
-    # PASS THROUGH FIELDS
+    # KEEP MCP + INTERNET
     # =====================================================
     passthrough_fields = [
 
         "tools",
         "tool_choice",
-        "system",
-        "metadata",
-        "betas",
+        "web_search",
         "mcp_servers",
         "plugins",
-        "web_search",
-        "response_format",
-        "parallel_tool_calls"
+        "parallel_tool_calls",
+        "response_format"
     ]
 
     for field in passthrough_fields:
 
         if field in body:
+
             payload[field] = body[field]
 
+    # =====================================================
+    # CLEAN BROKEN CLAUDE TOOLS ONLY
+    # =====================================================
+    if "tools" in payload:
+
+        payload["tools"] = clean_tools(
+            payload["tools"]
+        )
+
+    # =====================================================
+    # ENABLE INTERNET
+    # =====================================================
+    payload["web_search"] = True
+
     # =====================================================
     # LOGS
     # =====================================================
@@ -555,15 +659,18 @@ async def messages(
     # =====================================================
     headers = {
 
+        # IMPORTANT
         "x-api-key": api_key,
 
         "Authorization": f"Bearer {api_key}",
 
-        "anthropic-version": "2023-06-01",
-
         "Content-Type": "application/json",
 
-        "Accept": "text/event-stream" if stream else "application/json",
+        "Accept": (
+            "text/event-stream"
+            if stream
+            else "application/json"
+        ),
 
         "Origin": "https://opencode.ai",
 
@@ -591,44 +698,53 @@ async def messages(
                 f"[{req_id}] Attempt {attempt}"
             )
 
-            # =================================================
-            # STREAM MODE
-            # =================================================
-            if stream:
+            response = await client.post(
+                UPSTREAM_URL,
+                json=payload,
+                headers=headers
+            )
 
-                response = await client.post(
-                    UPSTREAM_URL,
-                    json=payload,
-                    headers=headers
-                )
+            logger.info(
+                f"[{req_id}] STATUS -> {response.status_code}"
+            )
 
-                logger.info(
-                    f"[{req_id}] STATUS -> {response.status_code}"
-                )
+            raw = response.text.strip()
 
-                raw = response.text[:1000]
+            # =================================================
+            # FAIL
+            # =================================================
+            if response.status_code != 200:
 
-                if response.status_code != 200:
+                logger.warning(
+                    f"[{req_id}] FAILED -> {raw}"
+                )
 
-                    logger.warning(
-                        f"[{req_id}] FAILED -> {raw}"
-                    )
+                last_error = raw
 
-                    last_error = raw
+                await asyncio.sleep(RETRY_DELAY)
 
-                    await asyncio.sleep(RETRY_DELAY)
+                continue
 
-                    continue
+            # =================================================
+            # STREAM MODE
+            # =================================================
+            if stream:
 
                 return StreamingResponse(
-                    stream_sse_response(
+
+                    anthropic_stream_response(
                         response,
                         requested_model
                     ),
+
                     media_type="text/event-stream",
+
                     headers={
+
                         "Cache-Control": "no-cache",
+
                         "Connection": "keep-alive",
+
                         "X-Accel-Buffering": "no"
                     }
                 )
@@ -636,64 +752,38 @@ async def messages(
             # =================================================
             # NORMAL MODE
             # =================================================
-            else:
-
-                response = await client.post(
-                    UPSTREAM_URL,
-                    json=payload,
-                    headers=headers
-                )
+            if not raw:
 
-                logger.info(
-                    f"[{req_id}] STATUS -> {response.status_code}"
+                return JSONResponse(
+                    status_code=502,
+                    content={
+                        "error": "Empty upstream response"
+                    }
                 )
 
-                raw = response.text.strip()
-
-                if response.status_code != 200:
-
-                    logger.warning(
-                        f"[{req_id}] FAILED -> {raw}"
-                    )
-
-                    last_error = raw
-
-                    await asyncio.sleep(RETRY_DELAY)
-
-                    continue
-
-                if not raw:
-
-                    return JSONResponse(
-                        status_code=502,
-                        content={
-                            "error": "Empty upstream response"
-                        }
-                    )
-
-                try:
-
-                    parsed = response.json()
-
-                except Exception:
+            try:
 
-                    return JSONResponse(
-                        status_code=502,
-                        content={
-                            "error": "Invalid JSON",
-                            "raw": raw
-                        }
-                    )
+                parsed = response.json()
 
-                anthropic_response = convert_to_anthropic_format(
-                    parsed,
-                    requested_model
-                )
+            except Exception:
 
                 return JSONResponse(
-                    content=anthropic_response
+                    status_code=502,
+                    content={
+                        "error": "Invalid JSON",
+                        "raw": raw
+                    }
                 )
 
+            anthropic_response = convert_to_anthropic_format(
+                parsed,
+                requested_model
+            )
+
+            return JSONResponse(
+                content=anthropic_response
+            )
+
         except Exception as e:
 
             last_error = str(e)