Update app.py

app.py

@@ -10,9 +10,8 @@ from fastapi import FastAPI, Request, Header
 from fastapi.responses import JSONResponse, StreamingResponse
 
 # =========================================================
-# LOGGING
+# LOGGING CONFIGURATION
 # =========================================================
-
 logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s [%(levelname)s] %(message)s"
@@ -20,13 +19,12 @@ logging.basicConfig(
 logger = logging.getLogger("gateway")
 
 # =========================================================
-# CONFIG
+# CONFIGURATION & ENVIRONMENT VARIABLES
 # =========================================================
-
 OPENCODE_API_KEY = os.getenv("OPENCODE_API_KEY", "").strip()
 UPSTREAM_URL     = "https://opencode.ai/zen/v1/chat/completions"
 MAX_RETRIES      = 5
-RETRY_DELAY      = 3
+RETRY_DELAY      = 2
 
 UPSTREAM_HEADERS = {
     "Content-Type": "application/json",
@@ -36,7 +34,7 @@ UPSTREAM_HEADERS = {
     "User-Agent": (
         "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
         "AppleWebKit/537.36 (KHTML, like Gecko) "
-        "Chrome/124.0 Safari/537.36"
+        "Chrome/125.0.0.0 Safari/537.36"
     ),
 }
 
@@ -47,42 +45,31 @@ STREAM_HEADERS = {
 }
 
 # =========================================================
-# MODEL MAP
+# DYNAMIC MODEL POOL (To avoid 401 & 429 errors)
 # =========================================================
-
-# Free models pool — used for round-robin on each request
+# Removed unstable models that caused 401 Unauthorized in logs
 _FREE_POOL = [
     "deepseek-v4-flash-free",
-    "qwen3.6-plus-free",
-    "minimax-m2.5-free",
-    "nemotron-3-super-free",
-    "big-pickle",
+    "nemotron-3-super-free"
 ]
 _pool_idx = 0
 
-
 def _pick_free_model():
-    """Round-robin across free models to avoid hitting one limit."""
+    """Fallback mechanism using round-robin for stable models."""
     global _pool_idx
     model = _FREE_POOL[_pool_idx % len(_FREE_POOL)]
     _pool_idx += 1
     return model
 
-
 MODEL_MAP = {
-    # Claude models -> round-robin free pool (resolved at request time)
-    "claude-sonnet-4-6":         None,
+    "claude-sonnet-4-6":         None,  # Dynamic resolution
     "claude-sonnet-4-5":         None,
     "claude-haiku-4-6":          None,
     "claude-haiku-4-5":          None,
     "claude-haiku-4-5-20251001": None,
     "claude-opus-4-6":           "nemotron-3-super-free",
-    # Direct aliases
     "deepseek-v4-flash-free":    "deepseek-v4-flash-free",
     "nemotron-3-super-free":     "nemotron-3-super-free",
-    "qwen3.6-plus-free":         "qwen3.6-plus-free",
-    "minimax-m2.5-free":         "minimax-m2.5-free",
-    "big-pickle":                "big-pickle",
 }
 
 DEFAULT_MODEL = "deepseek-v4-flash-free"
@@ -90,37 +77,32 @@ 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
     ],
 }
 
 # =========================================================
-# BROWSER TOOLS — strip before sending to DeepSeek
+# CONNECTOR PROMPT BUILDER
 # =========================================================
-
-_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",
-}
+def _build_connector_prompt(tools):
+    """Injects tool metadata into the system prompt to guide the model."""
+    if not tools:
+        return ""
+    
+    prompt = "💡 SYSTEM CONNECTOR: You have access to real-time tools and local environment execution.\n"
+    prompt += "Available Tools:\n"
+    for t in tools:
+        name = t.get("name", "unknown")
+        desc = t.get("description", "No description")
+        prompt += f"- `{name}`: {desc}\n"
+    prompt += "When a tool is needed, respond with the appropriate tool call sequence seamlessly."
+    return prompt
 
 # =========================================================
 # 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 _ThinkParser:
-
     OPEN  = "<think>"
     CLOSE = "</think>"
 
@@ -129,7 +111,6 @@ class _ThinkParser:
         self._in  = False
 
     def feed(self, text):
-        """Yield (is_thinking, chunk) tuples."""
         self._buf += text
         while self._buf:
             prev = len(self._buf)
@@ -153,7 +134,6 @@ class _ThinkParser:
         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):]
@@ -163,10 +143,7 @@ class _ThinkParser:
             br = self._buf.rfind("<")
             if br != -1:
                 tail = self._buf[br:]
-                if (
-                    len(tail) < len(self.OPEN)
-                    and self.OPEN.startswith(tail)
-                ):
+                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
@@ -185,10 +162,7 @@ class _ThinkParser:
             br = self._buf.rfind("<")
             if br != -1:
                 tail = self._buf[br:]
-                if (
-                    len(tail) < len(self.CLOSE)
-                    and self.CLOSE.startswith(tail)
-                ):
+                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
@@ -202,14 +176,9 @@ class _ThinkParser:
         return (True, thinking) if thinking else None
 
 # =========================================================
-# SCHEMA FIX  (DeepSeek rejects type:null)
+# JSON SCHEMA REPAIR
 # =========================================================
-
-_VALID_TYPES = {
-    "object", "array", "string",
-    "number", "boolean", "integer",
-}
-
+_VALID_TYPES = {"object", "array", "string", "number", "boolean", "integer"}
 
 def _fix_schema(schema):
     if not isinstance(schema, dict):
@@ -221,11 +190,8 @@ def _fix_schema(schema):
     return schema
 
 # =========================================================
-# REASONING EXTRACTION
-# Reads thinking back from previous assistant messages so
-# DeepSeek receives reasoning_content on the next turn.
+# REASONING & PROTOCOL NORMALIZE
 # =========================================================
-
 def _extract_reasoning(msg):
     rc = msg.get("reasoning_content")
     if isinstance(rc, str) and rc:
@@ -235,18 +201,13 @@ def _extract_reasoning(msg):
         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:
             return joined
     return None
 
-# =========================================================
-# SYSTEM HELPER
-# =========================================================
-
 def _system_to_str(raw):
     if isinstance(raw, str):
         return raw or ""
@@ -257,16 +218,9 @@ def _system_to_str(raw):
         )
     return ""
 
-# =========================================================
-# NORMALIZE MESSAGES
-# =========================================================
-
 def normalize_messages(messages):
-
     output = []
-
     for msg in messages:
-
         role    = msg.get("role", "user")
         content = msg.get("content", "")
 
@@ -280,47 +234,34 @@ def normalize_messages(messages):
             continue
 
         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
 
                 t = item.get("type", "")
-
                 if t == "text":
                     txt = item.get("text", "")
                     if txt:
                         text_parts.append(txt)
-
-                elif t == "thinking":
-                    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", {})
-                            ),
+                            "arguments": json.dumps(item.get("input", {})),
                         },
                     })
-
                 elif t == "tool_result":
                     rc_c = item.get("content", "")
                     if isinstance(rc_c, list):
                         rc_c = "\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_c
                         )
                     tool_results.append({
@@ -333,56 +274,35 @@ def normalize_messages(messages):
                 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:
                     am["reasoning_content"] = rc
                 output.append(am)
-
             elif tool_results:
                 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:
                         entry["reasoning_content"] = rc
                 output.append(entry)
-
             continue
 
         output.append({"role": role, "content": str(content)})
-
     return output
 
 # =========================================================
-# TOOLS
+# ANTHROPIC TO OPENAI TOOL BRIDGE
 # =========================================================
-
-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):
+    """Converts Anthropic style tool specifications into OpenAI schema format."""
     result = []
     for t in tools:
+        if not isinstance(t, dict):
+            continue
         result.append({
             "type": "function",
             "function": {
@@ -393,7 +313,6 @@ def convert_tools(tools):
         })
     return result
 
-
 def map_tool_choice(raw, has_tools):
     if not raw or not has_tools:
         return None
@@ -402,33 +321,24 @@ def map_tool_choice(raw, has_tools):
         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
 
 # =========================================================
-# CONVERT NORMAL RESPONSE
+# RESPONSE CONVERTERS
 # =========================================================
-
 _FINISH_MAP = {"tool_calls": "tool_use", "length": "max_tokens"}
 
-
 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", {})
-            stop_reason = _FINISH_MAP.get(
-                choice.get("finish_reason"), "end_turn"
-            )
+            stop_reason = _FINISH_MAP.get(choice.get("finish_reason"), "end_turn")
 
             reasoning = message.get("reasoning_content", "")
             if reasoning:
@@ -451,9 +361,8 @@ def convert_response(parsed, model):
                     "name":  fn.get("name", ""),
                     "input": args,
                 })
-
     except Exception as err:
-        logger.warning("convert_response: %s", err)
+        logger.warning("convert_response chain error: %s", err)
 
     if not blocks:
         blocks.append({"type": "text", "text": ""})
@@ -474,9 +383,8 @@ def convert_response(parsed, model):
     }
 
 # =========================================================
-# STREAM CONVERTER
+# STREAM CONVERTER (CLAUDE PROTOCOL SSE)
 # =========================================================
-
 _E_MSG_START   = "event: message_start\ndata: "
 _E_BLOCK_START = "event: content_block_start\ndata: "
 _E_BLOCK_DELTA = "event: content_block_delta\ndata: "
@@ -484,9 +392,7 @@ _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, model):
-
     msg_id      = f"msg_{uuid.uuid4().hex}"
     out_tokens  = 0
     stop_reason = "end_turn"
@@ -499,96 +405,61 @@ async def stream_convert(response, model):
 
     parser = _ThinkParser()
 
-    # message_start
-    yield (
-        _E_MSG_START
-        + json.dumps({
-            "type": "message_start",
-            "message": {
-                "id": msg_id, "type": "message",
-                "role": "assistant", "model": model,
-                "content": [], "stop_reason": None,
-                "stop_sequence": None,
-                "usage": {"input_tokens": 0, "output_tokens": 0},
-            },
-        })
-        + "\n\n"
-    )
+    yield (_E_MSG_START + json.dumps({
+        "type": "message_start",
+        "message": {
+            "id": msg_id, "type": "message", "role": "assistant", "model": model,
+            "content": [], "stop_reason": None, "stop_sequence": None,
+            "usage": {"input_tokens": 0, "output_tokens": 0},
+        },
+    }) + "\n\n")
+    
     yield 'event: ping\ndata: {"type":"ping"}\n\n'
 
-    # helpers
-
     def open_thinking():
         nonlocal thinking_idx, next_idx
         thinking_idx = next_idx
         next_idx += 1
-        return (
-            _E_BLOCK_START
-            + json.dumps({
-                "type": "content_block_start",
-                "index": thinking_idx,
-                "content_block": {"type": "thinking", "thinking": ""},
-            })
-            + "\n\n"
-        )
+        return (_E_BLOCK_START + json.dumps({
+            "type": "content_block_start", "index": thinking_idx,
+            "content_block": {"type": "thinking", "thinking": ""},
+        }) + "\n\n")
 
     def delta_thinking(text):
-        return (
-            _E_BLOCK_DELTA
-            + json.dumps({
-                "type": "content_block_delta",
-                "index": thinking_idx,
-                "delta": {"type": "thinking_delta", "thinking": text},
-            })
-            + "\n\n"
-        )
+        return (_E_BLOCK_DELTA + json.dumps({
+            "type": "content_block_delta", "index": thinking_idx,
+            "delta": {"type": "thinking_delta", "thinking": text},
+        }) + "\n\n")
 
     def open_text():
         nonlocal text_idx, next_idx
         text_idx  = next_idx
         next_idx += 1
-        return (
-            _E_BLOCK_START
-            + json.dumps({
-                "type": "content_block_start",
-                "index": text_idx,
-                "content_block": {"type": "text", "text": ""},
-            })
-            + "\n\n"
-        )
+        return (_E_BLOCK_START + json.dumps({
+            "type": "content_block_start", "index": text_idx,
+            "content_block": {"type": "text", "text": ""},
+        }) + "\n\n")
 
     def delta_text(text):
-        return (
-            _E_BLOCK_DELTA
-            + json.dumps({
-                "type": "content_block_delta",
-                "index": text_idx,
-                "delta": {"type": "text_delta", "text": text},
-            })
-            + "\n\n"
-        )
+        return (_E_BLOCK_DELTA + json.dumps({
+            "type": "content_block_delta", "index": text_idx,
+            "delta": {"type": "text_delta", "text": text},
+        }) + "\n\n")
 
     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"):
-                out_tokens = chunk["usage"].get(
-                    "completion_tokens", out_tokens
-                )
+                out_tokens = chunk["usage"].get("completion_tokens", out_tokens)
 
             choices = chunk.get("choices")
             if not choices:
@@ -603,7 +474,6 @@ async def stream_convert(response, model):
             elif finish == "length":
                 stop_reason = "max_tokens"
 
-            # reasoning_content field (DeepSeek native)
             rc = delta.get("reasoning_content")
             if rc:
                 if thinking_idx is None:
@@ -611,7 +481,6 @@ async def stream_convert(response, model):
                 yield delta_thinking(rc)
                 continue
 
-            # text content — may contain <think> tags
             raw_text = delta.get("content") or ""
             if raw_text:
                 for is_thinking, chunk_text in parser.feed(raw_text):
@@ -624,209 +493,125 @@ async def stream_convert(response, model):
                             yield open_text()
                         yield delta_text(chunk_text)
 
-            # tool calls
             for tc in delta.get("tool_calls") or []:
                 idx = tc.get("index", 0)
-
                 if idx not in tool_state:
-                    tool_state[idx] = {
-                        "id":   tc.get(
-                            "id", f"toolu_{uuid.uuid4().hex[:8]}"
-                        ),
-                        "name": "",
-                    }
+                    tool_state[idx] = {"id": tc.get("id", f"toolu_{uuid.uuid4().hex[:8]}"), "name": ""}
                     blk = next_idx
                     next_idx += 1
                     tool_idx[idx] = blk
                     fn_name = (tc.get("function") or {}).get("name", "")
                     tool_state[idx]["name"] = fn_name
-                    yield (
-                        _E_BLOCK_START
-                        + json.dumps({
-                            "type": "content_block_start",
-                            "index": blk,
-                            "content_block": {
-                                "type":  "tool_use",
-                                "id":    tool_state[idx]["id"],
-                                "name":  fn_name,
-                                "input": {},
-                            },
-                        })
-                        + "\n\n"
-                    )
+                    yield (_E_BLOCK_START + json.dumps({
+                        "type": "content_block_start", "index": blk,
+                        "content_block": {"type": "tool_use", "id": tool_state[idx]["id"], "name": fn_name, "input": {}},
+                    }) + "\n\n")
 
                 args = (tc.get("function") or {}).get("arguments", "")
                 if args:
-                    yield (
-                        _E_BLOCK_DELTA
-                        + json.dumps({
-                            "type":  "content_block_delta",
-                            "index": tool_idx[idx],
-                            "delta": {
-                                "type":         "input_json_delta",
-                                "partial_json": args,
-                            },
-                        })
-                        + "\n\n"
-                    )
+                    yield (_E_BLOCK_DELTA + json.dumps({
+                        "type": "content_block_delta", "index": tool_idx[idx],
+                        "delta": {"type": "input_json_delta", "partial_json": args},
+                    }) + "\n\n")
 
     except Exception as err:
-        logger.warning("stream error: %s", err)
+        logger.warning("Stream error mapping context: %s", err)
 
-    # flush leftover think-tag buffer
     for is_thinking, chunk_text in (parser.flush() or []):
         if is_thinking:
-            if thinking_idx is None:
-                yield open_thinking()
+            if thinking_idx is None: yield open_thinking()
             yield delta_thinking(chunk_text)
         else:
-            if text_idx is None:
-                yield open_text()
+            if text_idx is None: yield open_text()
             yield delta_text(chunk_text)
 
-    # close blocks
     if thinking_idx is not None:
-        yield (
-            _E_BLOCK_STOP
-            + json.dumps({
-                "type": "content_block_stop",
-                "index": thinking_idx,
-            })
-            + "\n\n"
-        )
-
+        yield (_E_BLOCK_STOP + json.dumps({"type": "content_block_stop", "index": thinking_idx}) + "\n\n")
     if text_idx is not None:
-        yield (
-            _E_BLOCK_STOP
-            + json.dumps({
-                "type": "content_block_stop",
-                "index": text_idx,
-            })
-            + "\n\n"
-        )
-
+        yield (_E_BLOCK_STOP + json.dumps({"type": "content_block_stop", "index": text_idx}) + "\n\n")
     for _, blk in tool_idx.items():
-        yield (
-            _E_BLOCK_STOP
-            + json.dumps({
-                "type": "content_block_stop",
-                "index": blk,
-            })
-            + "\n\n"
-        )
+        yield (_E_BLOCK_STOP + json.dumps({"type": "content_block_stop", "index": blk}) + "\n\n")
 
-    yield (
-        _E_MSG_DELTA
-        + json.dumps({
-            "type": "message_delta",
-            "delta": {
-                "stop_reason":   stop_reason,
-                "stop_sequence": None,
-            },
-            "usage": {"output_tokens": out_tokens},
-        })
-        + "\n\n"
-    )
+    yield (_E_MSG_DELTA + json.dumps({
+        "type": "message_delta",
+        "delta": {"stop_reason": stop_reason, "stop_sequence": None},
+        "usage": {"output_tokens": out_tokens},
+    }) + "\n\n")
 
-    yield (
-        _E_MSG_STOP
-        + json.dumps({"type": "message_stop"})
-        + "\n\n"
-    )
+    yield (_E_MSG_STOP + json.dumps({"type": "message_stop"}) + "\n\n")
 
 # =========================================================
-# FASTAPI
+# FASTAPI LIFECYCLE
 # =========================================================
-
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     app.state.client = httpx.AsyncClient(
         http2=False,
         timeout=httpx.Timeout(connect=20, read=300, write=60, pool=60),
-        limits=httpx.Limits(
-            max_connections=100,
-            max_keepalive_connections=20,
-        ),
+        limits=httpx.Limits(max_connections=150, max_keepalive_connections=30),
         follow_redirects=True,
     )
-    logger.info("Gateway started.")
+    logger.info("Gateway initialized successfully.")
     yield
     await app.state.client.aclose()
 
-
 app = FastAPI(lifespan=lifespan)
 
-
 @app.get("/")
-@app.head("/")
-async def root():
-    return {"status": "ok", "service": "OpenCode Gateway"}
-
-
 @app.get("/health")
 async def health():
-    return {"status": "healthy"}
-
+    return {"status": "healthy", "service": "OpenCode Claude Bridge"}
 
 @app.get("/v1/models")
 async def get_models():
     return _MODELS_CACHE
 
 # =========================================================
-# MAIN ENDPOINT
+# MAIN ROUTER ENDPOINT
 # =========================================================
-
 @app.post("/v1/messages")
 @app.post("/v1/chat/completions")
-async def messages(
-    request: Request,
-    authorization: str = Header(default=None),
-):
+async def messages(request: Request, authorization: str = Header(default=None)):
     req_id = uuid.uuid4().hex[:8]
 
     if not OPENCODE_API_KEY:
-        return JSONResponse(
-            status_code=401,
-            content={"error": "Missing 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"},
-        )
+        return JSONResponse(status_code=400, content={"error": "Invalid JSON payload"})
 
     requested_model = body.get("model", "claude-sonnet-4-6")
     _direct = MODEL_MAP.get(requested_model, DEFAULT_MODEL)
     mapped_model = _pick_free_model() if _direct is None else _direct
     stream          = bool(body.get("stream", False))
 
-    # tools
+    # Handle Tools and Connector Protocol Bridge
     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)
-    )
+    openai_tools = convert_tools(raw_tools)
+    tool_choice  = map_tool_choice(body.get("tool_choice"), bool(openai_tools))
 
-    # messages
     oai_messages = normalize_messages(body.get("messages", []))
 
-    # system
-    sys_str = _system_to_str(body.get("system", ""))
-    if sys_str:
-        oai_messages.insert(0, {"role": "system", "content": sys_str})
+    # Incorporate tools context natively into instructions if model behaves as connector
+    sys_str      = _system_to_str(body.get("system", ""))
+    connector_str = _build_connector_prompt(raw_tools)
+
+    parts = [p for p in [connector_str, sys_str] if p]
+    full_system = "\n\n---\n\n".join(parts)
+
+    if full_system:
+        oai_messages.insert(0, {"role": "system", "content": full_system})
 
-    # payload
     payload = {
         "model":       mapped_model,
         "messages":    oai_messages,
-        "temperature": body.get("temperature", 0.7),
-        "max_tokens":  min(body.get("max_tokens", 32000), 64000),
+        "temperature": body.get("temperature", 0.5),
+        "max_tokens":  min(body.get("max_tokens", 4096), 8192),
         "stream":      stream,
     }
+    
     if openai_tools:
         payload["tools"] = openai_tools
         if tool_choice is not None:
@@ -834,36 +619,21 @@ async def messages(
 
     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),
-    )
+    logger.info("[%s] Routing %s -> %s | Stream=%s | Tools Passed=%d", 
+                req_id, requested_model, mapped_model, stream, len(openai_tools))
 
-    client     = request.app.state.client
+    client = request.app.state.client
     last_error = None
 
     for attempt in range(1, MAX_RETRIES + 1):
-
         try:
-
-            # ---------- STREAM ----------
             if stream:
-
-                upstream_req = client.build_request(
-                    "POST", UPSTREAM_URL,
-                    json=payload, headers=headers,
-                )
+                upstream_req = client.build_request("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")
-                    logger.warning(
-                        "[%s] fail %d: %s",
-                        req_id, resp.status_code, raw_err[:200],
-                    )
+                    raw_err = (await resp.aread()).decode(errors="ignore")
+                    logger.warning("[%s] Upstream status %d: %s (Attempt %d)", req_id, resp.status_code, raw_err[:150], attempt)
                     last_error = raw_err
                     await asyncio.sleep(RETRY_DELAY)
                     continue
@@ -874,43 +644,22 @@ async def messages(
                     headers=STREAM_HEADERS,
                 )
 
-            # ---------- NORMAL ----------
-            resp = await client.post(
-                UPSTREAM_URL, json=payload, headers=headers,
-            )
-
+            # Non-stream configuration
+            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] Upstream failed with status %d (Attempt %d)", req_id, resp.status_code, attempt)
                 last_error = resp.text
                 await asyncio.sleep(RETRY_DELAY)
                 continue
 
-            if not resp.text.strip():
-                return JSONResponse(
-                    status_code=502,
-                    content={"error": "Empty upstream response"},
-                )
-
-            try:
-                parsed = resp.json()
-            except Exception:
-                return JSONResponse(
-                    status_code=502,
-                    content={"error": "Invalid upstream JSON"},
-                )
-
-            return JSONResponse(
-                content=convert_response(parsed, requested_model)
-            )
+            return JSONResponse(content=convert_response(resp.json(), requested_model))
 
         except Exception as err:
             last_error = str(err)
-            logger.exception("[%s] exception", req_id)
+            logger.warning("[%s] Connection error: %s (Attempt %d)", req_id, last_error, attempt)
             await asyncio.sleep(RETRY_DELAY)
 
     return JSONResponse(
         status_code=502,
-        content={"error": "Upstream failed", "details": last_error},
-    )
+        content={"error": "All retry paths to OpenCode upstream failed", "details": last_error[:200]},
+    )