Update app.py

app.py

@@ -1,22 +1,12 @@
-"""
-OpenCode Gateway — single-file Anthropic-compatible proxy
-Inspired by github.com/Alishahryar1/free-claude-code
-"""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import logging
 import os
+import json
 import uuid
+import asyncio
+import logging
 from contextlib import asynccontextmanager
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import Any
 
 import httpx
-from fastapi import FastAPI, Header, Request
+from fastapi import FastAPI, Request, Header
 from fastapi.responses import JSONResponse, StreamingResponse
 
 # =========================================================
@@ -25,9 +15,9 @@ from fastapi.responses import JSONResponse, StreamingResponse
 
 logging.basicConfig(
     level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(message)s",
+    format="%(asctime)s [%(levelname)s] %(message)s"
 )
-logger = logging.getLogger("OpenCodeGateway")
+logger = logging.getLogger("gateway")
 
 # =========================================================
 # CONFIG
@@ -40,9 +30,9 @@ RETRY_DELAY      = 3
 
 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) "
@@ -51,8 +41,8 @@ UPSTREAM_HEADERS = {
 }
 
 STREAM_HEADERS = {
-    "Cache-Control":    "no-cache",
-    "Connection":       "keep-alive",
+    "Cache-Control":     "no-cache",
+    "Connection":        "keep-alive",
     "X-Accel-Buffering": "no",
 }
 
@@ -60,14 +50,13 @@ STREAM_HEADERS = {
 # MODEL MAP
 # =========================================================
 
-MODEL_MAP: dict[str, str] = {
+MODEL_MAP = {
     "claude-sonnet-4-6":         "deepseek-v4-flash-free",
     "claude-sonnet-4-5":         "deepseek-v4-flash-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",
-    # 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",
@@ -80,125 +69,128 @@ DEFAULT_MODEL = "deepseek-v4-flash-free"
 _MODELS_CACHE = {
     "object": "list",
     "data": [
-        {"id": m, "object": "model", "created": 1710000000, "owned_by": "gateway"}
+        {
+            "id": m,
+            "object": "model",
+            "created": 1710000000,
+            "owned_by": "gateway"
+        }
         for m in MODEL_MAP
     ],
 }
 
 # =========================================================
-# THINK-TAG PARSER  (ported from free-claude-code)
+# BROWSER TOOLS — strip before sending to DeepSeek
 # =========================================================
-# DeepSeek / Qwen sometimes wrap reasoning in <think>...</think>
-# instead of a reasoning_content field. We parse both.
-
-class _CType(Enum):
-    TEXT    = "text"
-    THINKING = "thinking"
 
+_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",
+}
 
-@dataclass
-class _Chunk:
-    type: _CType
-    content: str
-
+# =========================================================
+# 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
+# =========================================================
 
-class ThinkTagParser:
-    """Streaming parser for <think>...</think> tags (chunk-boundary safe)."""
+class _ThinkParser:
 
     OPEN  = "<think>"
     CLOSE = "</think>"
 
-    def __init__(self) -> None:
-        self._buf: str = ""
-        self._in: bool = False
+    def __init__(self):
+        self._buf = ""
+        self._in  = False
 
-    def feed(self, text: str):
+    def feed(self, text):
+        """Yield (is_thinking, chunk) tuples."""
         self._buf += text
         while self._buf:
             prev = len(self._buf)
-            chunk = self._parse_inside() if self._in else self._parse_outside()
-            if chunk:
-                yield chunk
+            result = self._step()
+            if result is not None:
+                yield result
             elif len(self._buf) == prev:
                 break
 
     def flush(self):
         if self._buf:
-            yield _Chunk(_CType.THINKING if self._in else _CType.TEXT, self._buf)
+            yield (self._in, self._buf)
             self._buf = ""
 
-    def _parse_outside(self):
-        idx = self._buf.find(self.OPEN)
-        orphan = self._buf.find(self.CLOSE)
-        if orphan != -1 and (idx == -1 or orphan < idx):
-            pre = self._buf[:orphan]
-            self._buf = self._buf[orphan + len(self.CLOSE):]
-            return _Chunk(_CType.TEXT, pre) if pre else None
-        if idx == -1:
+    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 = self._buf[:br], self._buf[br:]
-                    return _Chunk(_CType.TEXT, emit) if emit else None
-            emit, self._buf = self._buf, ""
-            return _Chunk(_CType.TEXT, emit) if emit else None
-        pre = self._buf[:idx]
-        self._buf = self._buf[idx + len(self.OPEN):]
+                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 _Chunk(_CType.TEXT, pre) if pre else None
+        return (False, pre) if pre else None
 
-    def _parse_inside(self):
-        idx = self._buf.find(self.CLOSE)
-        if idx == -1:
+    def _inside(self):
+        c = self._buf.find(self.CLOSE)
+        if c == -1:
             br = self._buf.rfind("<")
-            if br != -1 and len(self._buf) - br < len(self.CLOSE):
+            if br != -1:
                 tail = self._buf[br:]
-                if self.CLOSE.startswith(tail):
-                    emit, self._buf = self._buf[:br], self._buf[br:]
-                    return _Chunk(_CType.THINKING, emit) if emit else None
-            emit, self._buf = self._buf, ""
-            return _Chunk(_CType.THINKING, emit) if emit else None
-        thinking = self._buf[:idx]
-        self._buf = self._buf[idx + len(self.CLOSE):]
-        self._in = False
-        return _Chunk(_CType.THINKING, thinking) if thinking else None
-
-# =========================================================
-# BROWSER TOOLS FILTER
-# =========================================================
-# OpenCode sends Chrome-extension tools that DeepSeek cannot
-# use. We strip them silently.
-
-_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",
-}
-
+                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
 
-def _filter_tools(tools: list) -> list:
-    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
+        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"}
+_VALID_TYPES = {
+    "object", "array", "string",
+    "number", "boolean", "integer",
+}
 
 
-def _fix_schema(schema: Any) -> dict:
+def _fix_schema(schema):
     if not isinstance(schema, dict):
         return {"type": "object", "properties": {}}
     if schema.get("type") not in _VALID_TYPES:
@@ -209,22 +201,21 @@ def _fix_schema(schema: Any) -> dict:
 
 # =========================================================
 # REASONING EXTRACTION
+# Reads thinking back from previous assistant messages so
+# DeepSeek receives reasoning_content on the next turn.
 # =========================================================
-# Reads reasoning_content back from a "thinking" block so
-# DeepSeek receives it on the next turn (its requirement).
 
-def _extract_reasoning(msg: dict) -> str | None:
-    # 1. top-level field
+def _extract_reasoning(msg):
     rc = msg.get("reasoning_content")
     if isinstance(rc, str) and rc:
         return rc
-    # 2. Anthropic thinking content block
     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"
+            if isinstance(item, dict)
+            and item.get("type") == "thinking"
         ]
         joined = "".join(parts)
         if joined:
@@ -232,12 +223,10 @@ def _extract_reasoning(msg: dict) -> str | None:
     return None
 
 # =========================================================
-# NORMALIZE MESSAGES
+# SYSTEM HELPER
 # =========================================================
-# Converts Anthropic message format → OpenAI format.
-# Key: preserves reasoning_content so DeepSeek is happy.
 
-def _system_to_str(raw: Any) -> str:
+def _system_to_str(raw):
     if isinstance(raw, str):
         return raw or ""
     if isinstance(raw, list):
@@ -247,17 +236,21 @@ def _system_to_str(raw: Any) -> str:
         )
     return ""
 
+# =========================================================
+# NORMALIZE MESSAGES
+# =========================================================
+
+def normalize_messages(messages):
 
-def normalize_messages(messages: list) -> list:
-    output: list[dict] = []
+    output = []
 
     for msg in messages:
+
         role    = msg.get("role", "user")
         content = msg.get("content", "")
 
-        # ---- plain string ----
         if isinstance(content, str):
-            entry: dict = {"role": role, "content": content}
+            entry = {"role": role, "content": content}
             if role == "assistant":
                 rc = _extract_reasoning(msg)
                 if rc:
@@ -265,13 +258,14 @@ def normalize_messages(messages: list) -> list:
             output.append(entry)
             continue
 
-        # ---- list of content blocks ----
         if isinstance(content, list):
-            text_parts:   list[str]  = []
-            tool_calls:   list[dict] = []
-            tool_results: list[dict] = []
+
+            text_parts   = []
+            tool_calls   = []
+            tool_results = []
 
             for item in content:
+
                 if not isinstance(item, dict):
                     text_parts.append(str(item))
                     continue
@@ -284,36 +278,43 @@ def normalize_messages(messages: list) -> list:
                         text_parts.append(txt)
 
                 elif t == "thinking":
-                    pass  # handled via _extract_reasoning
+                    pass  # recovered via _extract_reasoning
 
                 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", ""),
-                            "arguments": json.dumps(item.get("input", {})),
+                            "name": item.get("name", ""),
+                            "arguments": json.dumps(
+                                item.get("input", {})
+                            ),
                         },
                     })
 
                 elif t == "tool_result":
-                    rc_content = item.get("content", "")
-                    if isinstance(rc_content, list):
-                        rc_content = "\n".join(
-                            c.get("text", "") if isinstance(c, dict) else str(c)
-                            for c in rc_content
+                    rc_c = item.get("content", "")
+                    if isinstance(rc_c, list):
+                        rc_c = "\n".join(
+                            c.get("text", "")
+                            if isinstance(c, dict) else str(c)
+                            for c in rc_c
                         )
                     tool_results.append({
                         "role":         "tool",
                         "tool_call_id": item.get("tool_use_id", ""),
-                        "content":      str(rc_content),
+                        "content":      str(rc_c),
                     })
 
             if tool_calls:
-                am: dict = {
+                am = {
                     "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
+                    ),
                 }
                 rc = _extract_reasoning(msg)
                 if rc:
@@ -324,7 +325,10 @@ def normalize_messages(messages: list) -> list:
                 output.extend(tool_results)
 
             else:
-                entry = {"role": role, "content": "\n".join(text_parts)}
+                entry = {
+                    "role":    role,
+                    "content": "\n".join(text_parts),
+                }
                 if role == "assistant":
                     rc = _extract_reasoning(msg)
                     if rc:
@@ -338,25 +342,38 @@ def normalize_messages(messages: list) -> list:
     return output
 
 # =========================================================
-# TOOLS → OPENAI FORMAT
+# TOOLS
 # =========================================================
 
-def convert_tools(tools: list) -> list:
+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(tools):
     result = []
-    for tool in tools:
-        schema = _fix_schema(tool.get("input_schema", {}))
+    for t in tools:
         result.append({
             "type": "function",
             "function": {
-                "name":        tool.get("name", ""),
-                "description": tool.get("description", ""),
-                "parameters":  schema,
+                "name":        t.get("name", ""),
+                "description": t.get("description", ""),
+                "parameters":  _fix_schema(t.get("input_schema", {})),
             },
         })
     return result
 
 
-def map_tool_choice(raw: Any, has_tools: bool) -> Any:
+def map_tool_choice(raw, has_tools):
     if not raw or not has_tools:
         return None
     if isinstance(raw, dict):
@@ -364,104 +381,30 @@ def map_tool_choice(raw: Any, has_tools: bool) -> Any:
         if t == "any":
             return "required"
         if t == "tool":
-            return {"type": "function", "function": {"name": raw.get("name", "")}}
+            return {
+                "type": "function",
+                "function": {"name": raw.get("name", "")}
+            }
         return t
     return raw
 
 # =========================================================
-# SKILLS SYSTEM PROMPT
-# =========================================================
-
-def _build_skills_prompt(tools: list) -> str:
-    if not tools:
-        return ""
-
-    names = {t.get("name", "") for t in tools if isinstance(t, dict)}
-    sections: list[str] = []
-
-    web = {"web_search", "search", "brave_search", "tavily_search"}
-    if names & web:
-        sections.append(
-            "- WEB SEARCH: Search the internet in real time for current info, "
-            "news, docs or prices. ALWAYS call the tool before answering."
-        )
-
-    exe = {"execute_command", "run_command", "bash", "shell", "terminal"}
-    if names & exe:
-        sections.append(
-            "- CODE EXECUTION: Run shell commands directly. Use it to compile, "
-            "test, install packages or perform any system operation."
-        )
-
-    fil = {"read_file", "write_file", "create_file", "edit_file", "list_directory"}
-    if names & fil:
-        sections.append(
-            "- FILE SYSTEM: Read, write, create and edit files. "
-            "When asked for a document, CSV or config file, create it on disk."
-        )
-
-    known = web | exe | fil | _BROWSER_TOOLS | {""}
-    other = names - known
-    if other:
-        sections.append(
-            f"- OTHER TOOLS: {', '.join(sorted(other))}. "
-            "Use them whenever they are the most direct solution."
-        )
-
-    if not sections:
-        return ""
-
-    return "\n".join([
-        "## Your capabilities in this session",
-        "",
-        "You have the following tools and MUST use them proactively:",
-        "",
-        *sections,
-        "",
-        "Always prefer calling a tool over saying you cannot do something.",
-    ])
-
-# =========================================================
-# BUILD PAYLOAD
-# =========================================================
-
-def build_payload(
-    body: dict,
-    messages: list,
-    tools: list,
-    tool_choice: Any,
-    model: str,
-    stream: bool,
-) -> dict:
-    payload: dict = {
-        "model":      model,
-        "messages":   messages,
-        "temperature": body.get("temperature", 0.7),
-        "max_tokens":  min(body.get("max_tokens", 32000), 64000),
-        "stream":      stream,
-    }
-    if tools:
-        payload["tools"] = tools
-        if tool_choice is not None:
-            payload["tool_choice"] = tool_choice
-    return payload
-
-# =========================================================
-# RESPONSE CONVERTER  (non-stream)
+# CONVERT NORMAL RESPONSE
 # =========================================================
 
 _FINISH_MAP = {"tool_calls": "tool_use", "length": "max_tokens"}
 
 
-def convert_response(parsed: dict, model: str) -> dict:
-    blocks: list[dict] = []
+def convert_response(parsed, model):
+
+    blocks      = []
     stop_reason = "end_turn"
 
     try:
         choices = parsed.get("choices") or []
         if choices:
-            choice  = choices[0]
-            message = choice.get("message", {})
+            choice      = choices[0]
+            message     = choice.get("message", {})
             stop_reason = _FINISH_MAP.get(
                 choice.get("finish_reason"), "end_turn"
             )
@@ -487,8 +430,9 @@ def convert_response(parsed: dict, model: str) -> dict:
                     "name":  fn.get("name", ""),
                     "input": args,
                 })
+
     except Exception as err:
-        logger.warning("convert_response error: %s", err)
+        logger.warning("convert_response: %s", err)
 
     if not blocks:
         blocks.append({"type": "text", "text": ""})
@@ -511,45 +455,39 @@ def convert_response(parsed: dict, model: str) -> dict:
 # =========================================================
 # STREAM CONVERTER
 # =========================================================
-# Handles:
-#   - reasoning_content field  (DeepSeek native)
-#   - <think>…</think> tags    (Qwen / others)
-# Both are emitted as Anthropic "thinking" blocks so the
-# client stores them and echoes them back on the next turn.
 
-_EVT_MSG_START    = "event: message_start\ndata: "
-_EVT_BLOCK_START  = "event: content_block_start\ndata: "
-_EVT_BLOCK_DELTA  = "event: content_block_delta\ndata: "
-_EVT_BLOCK_STOP   = "event: content_block_stop\ndata: "
-_EVT_MSG_DELTA    = "event: message_delta\ndata: "
-_EVT_MSG_STOP     = "event: message_stop\ndata: "
+_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: "
 
 
-async def stream_convert(response: httpx.Response, model: str):
+async def stream_convert(response, model):
 
-    msg_id       = f"msg_{uuid.uuid4().hex}"
-    in_tokens    = 0
-    out_tokens   = 0
-    stop_reason  = "end_turn"
+    msg_id      = f"msg_{uuid.uuid4().hex}"
+    out_tokens  = 0
+    stop_reason = "end_turn"
 
-    # block index tracking
-    thinking_idx: int | None = None
-    text_idx:     int | None = None
-    tool_idx:     dict[int, int] = {}
-    tool_state:   dict[int, dict] = {}
-    next_idx      = 0
+    thinking_idx = None
+    text_idx     = None
+    tool_idx     = {}
+    tool_state   = {}
+    next_idx     = 0
 
-    think_parser = ThinkTagParser()
+    parser = _ThinkParser()
 
-    # ---- message_start ----
+    # message_start
     yield (
-        f"{_EVT_MSG_START}"
+        _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,
+                "id": msg_id, "type": "message",
+                "role": "assistant", "model": model,
+                "content": [], "stop_reason": None,
+                "stop_sequence": None,
                 "usage": {"input_tokens": 0, "output_tokens": 0},
             },
         })
@@ -557,14 +495,14 @@ async def stream_convert(response: httpx.Response, model: str):
     )
     yield 'event: ping\ndata: {"type":"ping"}\n\n'
 
-    # -------- helpers --------
+    # helpers
 
-    def _open_thinking():
+    def open_thinking():
         nonlocal thinking_idx, next_idx
         thinking_idx = next_idx
         next_idx += 1
         return (
-            f"{_EVT_BLOCK_START}"
+            _E_BLOCK_START
             + json.dumps({
                 "type": "content_block_start",
                 "index": thinking_idx,
@@ -573,9 +511,9 @@ async def stream_convert(response: httpx.Response, model: str):
             + "\n\n"
         )
 
-    def _delta_thinking(text: str) -> str:
+    def delta_thinking(text):
         return (
-            f"{_EVT_BLOCK_DELTA}"
+            _E_BLOCK_DELTA
             + json.dumps({
                 "type": "content_block_delta",
                 "index": thinking_idx,
@@ -584,12 +522,12 @@ async def stream_convert(response: httpx.Response, model: str):
             + "\n\n"
         )
 
-    def _open_text():
+    def open_text():
         nonlocal text_idx, next_idx
         text_idx  = next_idx
         next_idx += 1
         return (
-            f"{_EVT_BLOCK_START}"
+            _E_BLOCK_START
             + json.dumps({
                 "type": "content_block_start",
                 "index": text_idx,
@@ -598,9 +536,9 @@ async def stream_convert(response: httpx.Response, model: str):
             + "\n\n"
         )
 
-    def _delta_text(text: str) -> str:
+    def delta_text(text):
         return (
-            f"{_EVT_BLOCK_DELTA}"
+            _E_BLOCK_DELTA
             + json.dumps({
                 "type": "content_block_delta",
                 "index": text_idx,
@@ -609,13 +547,15 @@ async def stream_convert(response: httpx.Response, model: str):
             + "\n\n"
         )
 
-    # -------- main loop --------
     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
 
@@ -624,55 +564,55 @@ async def stream_convert(response: httpx.Response, model: str):
             except Exception:
                 continue
 
-            # usage
             if chunk.get("usage"):
-                u = chunk["usage"]
-                in_tokens  = u.get("prompt_tokens",     in_tokens)
-                out_tokens = u.get("completion_tokens", out_tokens)
+                out_tokens = chunk["usage"].get(
+                    "completion_tokens", out_tokens
+                )
 
             choices = chunk.get("choices")
             if not choices:
                 continue
 
-            choice       = choices[0]
-            delta        = choice.get("delta", {})
-            finish       = choice.get("finish_reason")
+            choice = choices[0]
+            delta  = choice.get("delta", {})
+            finish = choice.get("finish_reason")
 
             if finish == "tool_calls":
                 stop_reason = "tool_use"
             elif finish == "length":
                 stop_reason = "max_tokens"
 
-            # ---- reasoning_content (DeepSeek native field) ----
+            # reasoning_content field (DeepSeek native)
             rc = delta.get("reasoning_content")
             if rc:
                 if thinking_idx is None:
-                    yield _open_thinking()
-                yield _delta_thinking(rc)
+                    yield open_thinking()
+                yield delta_thinking(rc)
                 continue
 
-            # ---- text content (may contain <think> tags) ----
+            # text content — may contain <think> tags
             raw_text = delta.get("content") or ""
             if raw_text:
-                for c in think_parser.feed(raw_text):
-                    if c.type == _CType.THINKING:
+                for is_thinking, chunk_text in parser.feed(raw_text):
+                    if is_thinking:
                         if thinking_idx is None:
-                            yield _open_thinking()
-                        yield _delta_thinking(c.content)
+                            yield open_thinking()
+                        yield delta_thinking(chunk_text)
                     else:
                         if text_idx is None:
-                            yield _open_text()
-                        yield _delta_text(c.content)
+                            yield open_text()
+                        yield delta_text(chunk_text)
 
-            # ---- tool calls ----
+            # 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]}"),
+                        "id":   tc.get(
+                            "id", f"toolu_{uuid.uuid4().hex[:8]}"
+                        ),
                         "name": "",
-                        "args": "",
                     }
                     blk = next_idx
                     next_idx += 1
@@ -680,7 +620,7 @@ async def stream_convert(response: httpx.Response, model: str):
                     fn_name = (tc.get("function") or {}).get("name", "")
                     tool_state[idx]["name"] = fn_name
                     yield (
-                        f"{_EVT_BLOCK_START}"
+                        _E_BLOCK_START
                         + json.dumps({
                             "type": "content_block_start",
                             "index": blk,
@@ -694,16 +634,17 @@ async def stream_convert(response: httpx.Response, model: str):
                         + "\n\n"
                     )
 
-                fn   = tc.get("function") or {}
-                args = fn.get("arguments", "")
+                args = (tc.get("function") or {}).get("arguments", "")
                 if args:
-                    tool_state[idx]["args"] += args
                     yield (
-                        f"{_EVT_BLOCK_DELTA}"
+                        _E_BLOCK_DELTA
                         + json.dumps({
                             "type":  "content_block_delta",
                             "index": tool_idx[idx],
-                            "delta": {"type": "input_json_delta", "partial_json": args},
+                            "delta": {
+                                "type":         "input_json_delta",
+                                "partial_json": args,
+                            },
                         })
                         + "\n\n"
                     )
@@ -712,49 +653,68 @@ async def stream_convert(response: httpx.Response, model: str):
         logger.warning("stream error: %s", err)
 
     # flush leftover think-tag buffer
-    for c in think_parser.flush() or []:
-        if c.type == _CType.THINKING:
+    for is_thinking, chunk_text in (parser.flush() or []):
+        if is_thinking:
             if thinking_idx is None:
-                yield _open_thinking()
-            yield _delta_thinking(c.content)
+                yield open_thinking()
+            yield delta_thinking(chunk_text)
         else:
             if text_idx is None:
-                yield _open_text()
-            yield _delta_text(c.content)
+                yield open_text()
+            yield delta_text(chunk_text)
 
     # close blocks
-    for idx in ([thinking_idx] if thinking_idx is not None else []):
+    if thinking_idx is not None:
         yield (
-            f"{_EVT_BLOCK_STOP}"
-            + json.dumps({"type": "content_block_stop", "index": idx})
+            _E_BLOCK_STOP
+            + json.dumps({
+                "type": "content_block_stop",
+                "index": thinking_idx,
+            })
             + "\n\n"
         )
+
     if text_idx is not None:
         yield (
-            f"{_EVT_BLOCK_STOP}"
-            + json.dumps({"type": "content_block_stop", "index": text_idx})
+            _E_BLOCK_STOP
+            + json.dumps({
+                "type": "content_block_stop",
+                "index": text_idx,
+            })
             + "\n\n"
         )
+
     for _, blk in tool_idx.items():
         yield (
-            f"{_EVT_BLOCK_STOP}"
-            + json.dumps({"type": "content_block_stop", "index": blk})
+            _E_BLOCK_STOP
+            + json.dumps({
+                "type": "content_block_stop",
+                "index": blk,
+            })
             + "\n\n"
         )
 
     yield (
-        f"{_EVT_MSG_DELTA}"
+        _E_MSG_DELTA
         + json.dumps({
-            "type":  "message_delta",
-            "delta": {"stop_reason": stop_reason, "stop_sequence": None},
+            "type": "message_delta",
+            "delta": {
+                "stop_reason":   stop_reason,
+                "stop_sequence": None,
+            },
             "usage": {"output_tokens": out_tokens},
         })
         + "\n\n"
     )
-    yield f"{_EVT_MSG_STOP}" + json.dumps({"type": "message_stop"}) + "\n\n"
+
+    yield (
+        _E_MSG_STOP
+        + json.dumps({"type": "message_stop"})
+        + "\n\n"
+    )
 
 # =========================================================
-# FASTAPI APP
+# FASTAPI
 # =========================================================
 
 @asynccontextmanager
@@ -762,7 +722,10 @@ 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),
+        limits=httpx.Limits(
+            max_connections=100,
+            max_keepalive_connections=20,
+        ),
         follow_redirects=True,
     )
     logger.info("Gateway started.")
@@ -809,7 +772,10 @@ async def messages(
     try:
         body = await request.json()
     except Exception:
-        return JSONResponse(status_code=400, content={"error": "Invalid JSON"})
+        return JSONResponse(
+            status_code=400,
+            content={"error": "Invalid JSON"},
+        )
 
     requested_model = body.get("model", "claude-sonnet-4-6")
     mapped_model    = MODEL_MAP.get(requested_model, DEFAULT_MODEL)
@@ -819,45 +785,62 @@ async def messages(
     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))
+    tool_choice  = map_tool_choice(
+        body.get("tool_choice"), bool(openai_tools)
+    )
 
     # messages
     oai_messages = normalize_messages(body.get("messages", []))
 
-    # system prompt
-    sys_str     = _system_to_str(body.get("system", ""))
-    skills_str  = _build_skills_prompt(clean_tools)
-    full_system = "\n\n---\n\n".join(filter(None, [skills_str, sys_str]))
-    if full_system:
-        oai_messages.insert(0, {"role": "system", "content": full_system})
+    # system
+    sys_str = _system_to_str(body.get("system", ""))
+    if sys_str:
+        oai_messages.insert(0, {"role": "system", "content": sys_str})
+
+    # 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
 
-    payload = build_payload(
-        body, oai_messages, openai_tools, 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),
+        req_id, requested_model, mapped_model,
+        stream, len(openai_tools),
     )
 
     client     = request.app.state.client
     last_error = None
 
     for attempt in range(1, MAX_RETRIES + 1):
+
         try:
 
             # ---------- STREAM ----------
             if stream:
+
                 upstream_req = client.build_request(
-                    "POST", UPSTREAM_URL, json=payload, headers=headers
+                    "POST", UPSTREAM_URL,
+                    json=payload, headers=headers,
                 )
                 resp = await client.send(upstream_req, stream=True)
 
                 if resp.status_code != 200:
-                    raw_err = (await resp.aread()).decode(errors="ignore")
+                    raw_err = (
+                        await resp.aread()
+                    ).decode(errors="ignore")
                     logger.warning(
-                        "[%s] fail %d: %s", req_id, resp.status_code, raw_err[:200]
+                        "[%s] fail %d: %s",
+                        req_id, resp.status_code, raw_err[:200],
                     )
                     last_error = raw_err
                     await asyncio.sleep(RETRY_DELAY)
@@ -870,10 +853,14 @@ async def messages(
                 )
 
             # ---------- NORMAL ----------
-            resp = await client.post(UPSTREAM_URL, json=payload, headers=headers)
+            resp = await client.post(
+                UPSTREAM_URL, json=payload, headers=headers,
+            )
 
             if resp.status_code != 200:
-                logger.warning("[%s] fail %d", req_id, resp.status_code)
+                logger.warning(
+                    "[%s] fail %d", req_id, resp.status_code
+                )
                 last_error = resp.text
                 await asyncio.sleep(RETRY_DELAY)
                 continue
@@ -892,7 +879,9 @@ async def messages(
                     content={"error": "Invalid upstream JSON"},
                 )
 
-            return JSONResponse(content=convert_response(parsed, requested_model))
+            return JSONResponse(
+                content=convert_response(parsed, requested_model)
+            )
 
         except Exception as err:
             last_error = str(err)