Update app.py

app.py

@@ -1,994 +1,500 @@
 import os
 import json
-import uuid
-import asyncio
+import time
 import logging
-from contextlib import asynccontextmanager
-
-import httpx
-from fastapi import FastAPI, Request, Header
-from fastapi.responses import JSONResponse, StreamingResponse
-
-# =========================================================
-# LOGGING
-# =========================================================
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(message)s"
-)
-logger = logging.getLogger("gateway")
-
-# =========================================================
-# CONFIG
-# =========================================================
-
-OPENCODE_API_KEY = os.getenv("OPENCODE_API_KEY", "").strip()
-UPSTREAM_URL     = "https://opencode.ai/zen/v1/chat/completions"
-MAX_RETRIES      = 5
-RETRY_DELAY      = 3
-
-UPSTREAM_HEADERS = {
-    "Content-Type": "application/json",
-    "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) "
-        "Chrome/124.0 Safari/537.36"
-    ),
-}
-
-STREAM_HEADERS = {
-    "Cache-Control":     "no-cache",
-    "Connection":        "keep-alive",
-    "X-Accel-Buffering": "no",
-}
-
-# =========================================================
-# MODEL MAP
-# =========================================================
-
-# Only models confirmed working from logs (no 401)
-_FREE_POOL = [
-    "deepseek-v4-flash-free",
-    "nemotron-3-super-free",
-]
-_pool_idx = 0
-
-
-def _pick_free_model():
-    """Round-robin across confirmed free 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-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"
-
-_MODELS_CACHE = {
-    "object": "list",
-    "data": [
-        {
-            "id": m,
-            "object": "model",
-            "created": 1710000000,
-            "owned_by": "gateway"
-        }
-        for m in MODEL_MAP
-    ],
-}
-
-# =========================================================
-# BROWSER TOOLS — strip before sending to DeepSeek
-# =========================================================
-
-_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",
-}
+from typing import Any, Dict, List, Optional, Tuple
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import StreamingResponse, JSONResponse
+from pydantic import BaseModel
+import g4f
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("g4f-smart-router")
+
+# =====================================================
+# COOKIES
+# =====================================================
+def _load_cookies_raw() -> Dict[str, Any]:
+    raw_env = (os.getenv("COOKIES_JSON") or "").strip()
+
+    if raw_env:
+        try:
+            return json.loads(raw_env)
+        except Exception as e:
+            logger.warning(e)
 
-# =========================================================
-# 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>"
-
-    def __init__(self):
-        self._buf = ""
-        self._in  = False
-
-    def feed(self, text):
-        """Yield (is_thinking, chunk) tuples."""
-        self._buf += text
-        while self._buf:
-            prev = len(self._buf)
-            result = self._step()
-            if result is not None:
-                yield result
-            elif len(self._buf) == prev:
-                break
-
-    def flush(self):
-        if self._buf:
-            yield (self._in, self._buf)
-            self._buf = ""
-
-    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[: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 (False, pre) if pre else None
-
-    def _inside(self):
-        c = self._buf.find(self.CLOSE)
-        if c == -1:
-            br = self._buf.rfind("<")
-            if br != -1:
-                tail = self._buf[br:]
-                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
-
-        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",
-}
+    try:
+        if os.path.exists("cookies.json"):
+            with open("cookies.json", "r", encoding="utf-8") as f:
+                return json.load(f)
+    except Exception as e:
+        logger.warning(e)
 
+    return {}
 
-def _fix_schema(schema):
-    if not isinstance(schema, dict):
-        return {"type": "object", "properties": {}}
-    if schema.get("type") not in _VALID_TYPES:
-        schema = dict(schema)
-        schema["type"] = "object"
-        schema.setdefault("properties", {})
-    return schema
-
-# =========================================================
-# REASONING EXTRACTION
-# Reads thinking back from previous assistant messages so
-# DeepSeek receives reasoning_content on the next turn.
-# =========================================================
-
-def _extract_reasoning(msg):
-    rc = msg.get("reasoning_content")
-    if isinstance(rc, str) and rc:
-        return rc
-    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"
-        ]
-        joined = "".join(parts)
-        if joined:
-            return joined
-    return None
-
-# =========================================================
-# SYSTEM HELPER
-# =========================================================
-
-def _system_to_str(raw):
-    if isinstance(raw, str):
-        return raw or ""
-    if isinstance(raw, list):
-        return "\n".join(
-            item.get("text", "") if isinstance(item, dict) else str(item)
-            for item in raw
-        )
-    return ""
+def load_cookies() -> str:
+    data = _load_cookies_raw()
 
-# =========================================================
-# NORMALIZE MESSAGES
-# =========================================================
+    if not data:
+        return "⚠️ No Cookies"
 
-def normalize_messages(messages):
+    try:
+        from g4f.cookies import set_cookies
+    except Exception:
+        return "⚠️ Cookies Found"
 
-    output = []
+    for domain, vals in data.items():
+        try:
+            dom = domain if "." in domain else f".{domain}.com"
 
-    for msg in messages:
+            if isinstance(vals, list):
+                vals = {
+                    x["name"]: x["value"]
+                    for x in vals
+                    if isinstance(x, dict)
+                }
 
-        role    = msg.get("role", "user")
-        content = msg.get("content", "")
+            if isinstance(vals, dict):
+                set_cookies(dom, vals)
 
-        if isinstance(content, str):
-            entry = {"role": role, "content": content}
-            if role == "assistant":
-                rc = _extract_reasoning(msg)
-                if rc:
-                    entry["reasoning_content"] = rc
-            output.append(entry)
-            continue
+        except Exception as e:
+            logger.warning(e)
 
-        if isinstance(content, list):
+    return "✅ Cookies Loaded"
 
-            text_parts   = []
-            tool_calls   = []
-            tool_results = []
+COOKIE_STATUS = load_cookies()
 
-            for item in content:
+# =====================================================
+# PROVIDERS
+# =====================================================
+def get_provider(name: str):
+    try:
+        return getattr(g4f.Provider, name)
+    except:
+        return None
 
-                if not isinstance(item, dict):
-                    text_parts.append(str(item))
-                    continue
+REAL_PROVIDERS: Dict[str, Any] = {
+    "Qwen": get_provider("Qwen"),
+}
 
-                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]}"
-                        ),
-                        "type": "function",
-                        "function": {
-                            "name": item.get("name", ""),
-                            "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)
-                            for c in rc_c
-                        )
-                    tool_results.append({
-                        "role":         "tool",
-                        "tool_call_id": item.get("tool_use_id", ""),
-                        "content":      str(rc_c),
-                    })
-
-            if tool_calls:
-                am = {
-                    "role":       "assistant",
-                    "tool_calls": tool_calls,
-                    "content": (
-                        "\n".join(text_parts) if text_parts else None
-                    ),
-                }
-                rc = _extract_reasoning(msg)
-                if rc:
-                    am["reasoning_content"] = rc
-                output.append(am)
+REAL_PROVIDERS = {k: v for k, v in REAL_PROVIDERS.items() if v}
 
-            elif tool_results:
-                output.extend(tool_results)
+# =====================================================
+# MODELS
+# =====================================================
+PROVIDER_MODELS_FALLBACK: Dict[str, List[str]] = {
+    "Qwen": ["Qwen/Qwen3.6-35B-A3B"],
+}
 
-            else:
-                entry = {
-                    "role":    role,
-                    "content": "\n".join(text_parts),
-                }
-                if role == "assistant":
-                    rc = _extract_reasoning(msg)
-                    if rc:
-                        entry["reasoning_content"] = rc
-                output.append(entry)
+CLAUDE_MODEL_MAP: Dict[str, str] = {
+    "claude-opus-4-6":   "Qwen/Qwen3.6-35B-A3B",
+    "claude-sonnet-4-6": "Qwen/Qwen3.6-35B-A3B",
+    "claude-haiku-4-5":  "Qwen/Qwen3.6-35B-A3B",
+}
 
-            continue
+# =====================================================
+# MODEL DISCOVERY
+# =====================================================
+def _normalize_model_list(x: Any) -> List[str]:
+    out: List[str] = []
 
-        output.append({"role": role, "content": str(content)})
-
-    return output
-
-# =========================================================
-# TOOLS
-# =========================================================
-
-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 t in tools:
-        result.append({
-            "type": "function",
-            "function": {
-                "name":        t.get("name", ""),
-                "description": t.get("description", ""),
-                "parameters":  _fix_schema(t.get("input_schema", {})),
-            },
-        })
-    return result
+    if x is None:
+        return out
 
+    if isinstance(x, dict):
+        out = [str(k) for k in x.keys()]
+    elif isinstance(x, (list, tuple, set)):
+        out = [str(i) for i in x]
+    else:
+        out = [str(x)]
 
-def map_tool_choice(raw, has_tools):
-    if not raw or not has_tools:
-        return None
-    if isinstance(raw, dict):
-        t = raw.get("type", "auto")
-        if t == "any":
-            return "required"
-        if t == "tool":
-            return {
-                "type": "function",
-                "function": {"name": raw.get("name", "")}
-            }
-        return t
-    return raw
+    out = [m.strip() for m in out if m]
 
-# =========================================================
-# CONVERT NORMAL RESPONSE
-# =========================================================
+    seen = set()
+    uniq = []
 
-_FINISH_MAP = {"tool_calls": "tool_use", "length": "max_tokens"}
+    for m in out:
+        if m not in seen:
+            uniq.append(m)
+            seen.add(m)
 
+    return uniq
 
-def convert_response(parsed, model):
+def discover_provider_models(provider_obj: Any, provider_name: str) -> List[str]:
 
-    blocks      = []
-    stop_reason = "end_turn"
+    candidates = []
 
-    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"
-            )
-
-            reasoning = message.get("reasoning_content", "")
-            if reasoning:
-                blocks.append({"type": "thinking", "thinking": reasoning})
-
-            text = message.get("content") or ""
-            if text:
-                blocks.append({"type": "text", "text": text})
+    for attr in (
+        "models",
+        "model",
+        "default_model",
+        "available_models",
+        "supported_models"
+    ):
+        try:
+            if hasattr(provider_obj, attr):
+                candidates += _normalize_model_list(
+                    getattr(provider_obj, attr)
+                )
+        except:
+            pass
 
-            for tc in message.get("tool_calls") or []:
-                fn       = tc.get("function", {})
-                raw_args = fn.get("arguments", "{}")
-                try:
-                    args = json.loads(raw_args)
-                except Exception:
-                    args = {"raw": raw_args}
-                blocks.append({
-                    "type":  "tool_use",
-                    "id":    tc.get("id", f"toolu_{uuid.uuid4().hex[:8]}"),
-                    "name":  fn.get("name", ""),
-                    "input": args,
-                })
-
-    except Exception as err:
-        logger.warning("convert_response: %s", err)
-
-    if not blocks:
-        blocks.append({"type": "text", "text": ""})
-
-    usage = parsed.get("usage", {})
-    return {
-        "id":            f"msg_{uuid.uuid4().hex}",
-        "type":          "message",
-        "role":          "assistant",
-        "model":         model,
-        "content":       blocks,
-        "stop_reason":   stop_reason,
-        "stop_sequence": None,
-        "usage": {
-            "input_tokens":  usage.get("prompt_tokens", 0),
-            "output_tokens": usage.get("completion_tokens", 0),
-        },
-    }
+    for fn in ("get_models", "models_list", "list_models"):
+        try:
+            if hasattr(provider_obj, fn):
+                candidates += _normalize_model_list(
+                    getattr(provider_obj, fn)()
+                )
+        except:
+            pass
 
-# =========================================================
-# STREAM CONVERTER
-# =========================================================
-
-_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, model):
-
-    msg_id      = f"msg_{uuid.uuid4().hex}"
-    out_tokens  = 0
-    stop_reason = "end_turn"
-
-    thinking_idx = None
-    text_idx     = None
-    tool_idx     = {}
-    tool_state   = {}
-    next_idx     = 0
-
-    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 '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"
+    if not candidates:
+        candidates = PROVIDER_MODELS_FALLBACK.get(
+            provider_name,
+            ["Qwen/Qwen3.6-35B-A3B"]
         )
 
-    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"
-        )
+    seen = set()
+    uniq = []
 
-    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"
-        )
+    for m in candidates:
+        if m not in seen:
+            uniq.append(m)
+            seen.add(m)
 
-    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 uniq
 
+# =====================================================
+# STREAM CLEANER
+# =====================================================
+def clean_stream(chunk):
     try:
+        if isinstance(chunk, dict):
+            if 'choices' in chunk and chunk['choices']:
+                delta = chunk['choices'][0].get('delta', {})
+                if 'content' in delta:
+                    return delta['content']
+                if 'text' in delta:
+                    return delta['text']
+            if 'content' in chunk:
+                return chunk['content']
+            if 'text' in chunk:
+                return chunk['text']
+            return ""
+
+        if isinstance(chunk, str):
+            if chunk.strip().startswith("{") and chunk.strip().endswith("}"):
+                try:
+                    data = json.loads(chunk)
+                    if 'choices' in data and data['choices']:
+                        delta = data['choices'][0].get('delta', {})
+                        if 'content' in delta:
+                            return delta['content']
+                    if 'content' in data:
+                        return data['content']
+                    if 'text' in data:
+                        return data['text']
+                except:
+                    pass
+
+            chunk = chunk.replace('\\n', '\n').replace('\\r', '\r').replace('\\t', '    ')
+            chunk = chunk.replace('\\"', '"').replace("\\'", "'")
+            return chunk
+
+        return str(chunk)
+    except Exception as e:
+        logger.warning(f"خطأ في clean_stream: {e}")
+        return ""
 
-        async for raw in response.aiter_lines():
+# =====================================================
+# CACHE
+# =====================================================
+CACHE = {}
+CACHE_TS = {}
 
-            if not raw or not raw.startswith("data:"):
-                continue
+def _cache_get(key):
+    if key not in CACHE:
+        return None
+    return CACHE[key]
 
-            line = raw[5:].strip()
+def _cache_set(key, val):
+    CACHE[key] = val
+    CACHE_TS[key] = time.time()
 
-            if line == "[DONE]":
-                break
+# =====================================================
+# CHAT LOGIC
+# =====================================================
+_PROVIDER_MODEL_CACHE = {}
 
-            try:
-                chunk = json.loads(line)
-            except Exception:
-                continue
+def ask(message: str, history, provider_name: str, model_name: str):
+    history = history or []
+    message = (message or "").strip()
 
-            if chunk.get("usage"):
-                out_tokens = chunk["usage"].get(
-                    "completion_tokens", out_tokens
-                )
+    if not message:
+        yield ""
+        return
 
-            choices = chunk.get("choices")
-            if not choices:
-                continue
-
-            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 field (DeepSeek native)
-            rc = delta.get("reasoning_content")
-            if rc:
-                if thinking_idx is None:
-                    yield open_thinking()
-                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):
-                    if is_thinking:
-                        if thinking_idx is None:
-                            yield open_thinking()
-                        yield delta_thinking(chunk_text)
-                    else:
-                        if text_idx is None:
-                            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": "",
-                    }
-                    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"
-                    )
-
-                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"
-                    )
-
-    except Exception as err:
-        logger.warning("stream error: %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()
-            yield delta_thinking(chunk_text)
-        else:
-            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"
-        )
+    # تحويل نماذج Claude الوهمية إلى Qwen3.6-35B-A3B
+    model_name = CLAUDE_MODEL_MAP.get(model_name, "Qwen/Qwen3.6-35B-A3B")
+    provider_name = "Qwen"
 
-    if text_idx is not None:
-        yield (
-            _E_BLOCK_STOP
-            + json.dumps({
-                "type": "content_block_stop",
-                "index": text_idx,
-            })
-            + "\n\n"
-        )
+    key = f"{provider_name}|{model_name}|{message}"
 
-    for _, blk in tool_idx.items():
-        yield (
-            _E_BLOCK_STOP
-            + json.dumps({
-                "type": "content_block_stop",
-                "index": blk,
-            })
-            + "\n\n"
-        )
+    cached = _cache_get(key)
 
-    yield (
-        _E_MSG_DELTA
-        + json.dumps({
-            "type": "message_delta",
-            "delta": {
-                "stop_reason":   stop_reason,
-                "stop_sequence": None,
-            },
-            "usage": {"output_tokens": out_tokens},
-        })
-        + "\n\n"
-    )
+    if cached is not None:
+        yield cached
+        return
 
-    yield (
-        _E_MSG_STOP
-        + json.dumps({"type": "message_stop"})
-        + "\n\n"
-    )
-
-# =========================================================
-# CONNECTOR PROMPT
-# =========================================================
-# Teaches the model which tools it has and forces it to use
-# them — this is what makes it behave like real Claude with
-# connectors (web search, file system, MCP tools etc.)
+    msgs = []
 
-def _build_connector_prompt(tools):
-    if not tools:
-        return ""
-
-    names = {t.get("name", "") for t in tools if isinstance(t, dict)}
+    try:
+        if history:
+            if isinstance(history[0], dict):
+                for item in history[-40:]:
+                    role = item.get("role")
+                    content = item.get("content")
+                    if role and content:
+                        msgs.append({
+                            "role": str(role),
+                            "content": str(content)
+                        })
+            else:
+                for item in history[-20:]:
+                    if isinstance(item, (list, tuple)) and len(item) == 2:
+                        u = item[0]
+                        a = item[1]
+                        if u:
+                            msgs.append({
+                                "role": "user",
+                                "content": str(u)
+                            })
+                        if a:
+                            msgs.append({
+                                "role": "assistant",
+                                "content": str(a)
+                            })
+    except Exception as e:
+        logger.warning(e)
+
+    msgs.append({
+        "role": "user",
+        "content": message
+    })
+
+    pobj = REAL_PROVIDERS.get("Qwen")
+
+    if not pobj:
+        yield "❌ Qwen provider not available."
+        return
+
+    if "Qwen" not in _PROVIDER_MODEL_CACHE:
+        _PROVIDER_MODEL_CACHE["Qwen"] = discover_provider_models(pobj, "Qwen")
+
+    model_candidates = ["Qwen/Qwen3.6-35B-A3B"] + [
+        x for x in _PROVIDER_MODEL_CACHE["Qwen"]
+        if x != "Qwen/Qwen3.6-35B-A3B"
+    ]
 
-    sections = []
+    for m in model_candidates[:12]:
+        try:
+            stream = g4f.ChatCompletion.create(
+                model=m,
+                provider=pobj,
+                messages=msgs,
+                stream=True
+            )
 
-    # Web search
-    web = {
-        "web_search", "search", "brave_search",
-        "tavily_search", "web_search_tool",
-    }
-    if names & web:
-        sections.append(
-            "- WEB SEARCH available: call it immediately whenever the user"
-            " asks about current events, news, prices, docs, or any"
-            " real-time information. Never say you cannot search."
-        )
+            text = ""
 
-    # File system
-    fs = {
-        "read_file", "write_file", "create_file",
-        "edit_file", "list_directory", "list_files",
-        "str_replace_editor", "view_file",
-    }
-    if names & fs:
-        sections.append(
-            "- FILE SYSTEM available: read, write and create files on disk."
-            " When asked for a document, CSV, JSON or any file — create it."
-        )
+            for chunk in stream:
+                c = clean_stream(chunk)
 
-    # Code execution
-    exe = {
-        "execute_command", "run_command", "bash",
-        "shell", "terminal", "execute_code",
-    }
-    if names & exe:
-        sections.append(
-            "- CODE EXECUTION available: run shell commands directly."
-            " Use it to install packages, run scripts, or test code."
-        )
+                if c is None or c == "":
+                    continue
 
-    # MCP / other tools
-    known = web | fs | exe | _BROWSER_TOOLS | {""}
-    other = sorted(names - known)
-    if other:
-        sections.append(
-            "- ADDITIONAL TOOLS: " + ", ".join(other) + "."
-            " Use them whenever they are the most direct solution."
-        )
+                text += c
+                yield text
 
-    if not sections:
-        return ""
+            if text.strip():
+                _cache_set(key, text)
+                return
 
-    lines = [
-        "# Connector capabilities active in this session",
-        "",
-        "You have real tools connected. Use them proactively:",
-        "",
-    ] + sections + [
-        "",
-        "IMPORTANT: always call the relevant tool instead of saying"
-        " you cannot access external information.",
-    ]
-
-    return "\n".join(lines)
+        except Exception as e:
+            logger.warning(e)
+            continue
 
+    yield "❌ Failed with Qwen provider."
 
-# =========================================================
+# =====================================================
 # FASTAPI
-# =========================================================
-
-@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,
-        ),
-        follow_redirects=True,
+# =====================================================
+
+app = FastAPI(title="G4F API", description="G4F Smart Router API")
+
+API_KEY = os.getenv("API_KEY", "mysecretkey123")
+
+class ChatRequest(BaseModel):
+    message: str
+    provider: str = "Qwen"
+    model: str = "claude-sonnet-4-6"
+    history: List[Any] = []
+
+# =====================================================
+# MCP SUPPORT
+# =====================================================
+class MCPToolCall(BaseModel):
+    tool: str
+    parameters: Dict[str, Any] = {}
+
+class MCPRequest(BaseModel):
+    messages: List[Dict[str, Any]]
+    tools: List[Dict[str, Any]] = []
+    model: str = "claude-sonnet-4-6"
+
+def verify_api_key(request: Request):
+    auth = request.headers.get("Authorization")
+    if auth and auth.startswith("Bearer "):
+        key = auth.replace("Bearer ", "")
+        if key == API_KEY:
+            return True
+
+    x_api_key = request.headers.get("X-API-Key")
+    if x_api_key and x_api_key == API_KEY:
+        return True
+
+    raise HTTPException(
+        status_code=401,
+        detail="Invalid or missing API key. Use 'Authorization: Bearer KEY' or 'X-API-Key: KEY'"
     )
-    logger.info("Gateway started.")
-    yield
-    await app.state.client.aclose()
-
-
-app = FastAPI(lifespan=lifespan)
-
 
 @app.get("/")
-@app.head("/")
 async def root():
-    return {"status": "ok", "service": "OpenCode Gateway"}
-
+    return {
+        "message": "G4F API is running",
+        "endpoints": {
+            "GET /": "هذه الصفحة",
+            "GET /health": "التحقق من صحة الخادم",
+            "GET /providers": "قائمة المزودين والنماذج (يتطلب مفتاح)",
+            "POST /chat": "إرسال رسالة والحصول على رد (يتطلب مفتاح)",
+            "POST /chat/stream": "إرسال رسالة والحصول على رد متدفق (يتطلب مفتاح)",
+            "POST /v1/messages": "MCP / Claude-compatible endpoint (يتطلب مفتاح)",
+            "GET /v1/models": "قائمة النماذج بصيغة OpenAI (يتطلب مفتاح)"
+        },
+        "authentication": "Bearer YOUR_API_KEY or X-API-Key: YOUR_API_KEY",
+        "status": "✅ Server is working"
+    }
 
 @app.get("/health")
 async def health():
-    return {"status": "healthy"}
-
-
-@app.get("/v1/models")
-async def get_models():
-    return _MODELS_CACHE
-
-# =========================================================
-# MAIN ENDPOINT
-# =========================================================
-
-@app.post("/v1/messages")
-@app.post("/v1/chat/completions")
-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"},
-        )
-
-    try:
-        body = await request.json()
-    except Exception:
-        return JSONResponse(
-            status_code=400,
-            content={"error": "Invalid JSON"},
-        )
-
-    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
-    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)
-    )
+    return {"status": "ok", "cookies": COOKIE_STATUS, "providers": list(REAL_PROVIDERS.keys())}
 
-    # messages
-    oai_messages = normalize_messages(body.get("messages", []))
+@app.post("/chat")
+async def chat(request: Request, chat_req: ChatRequest):
+    verify_api_key(request)
 
-    # system
-    sys_str      = _system_to_str(body.get("system", ""))
-    connector_str = _build_connector_prompt(clean_tools)
+    full_response = ""
+    for chunk in ask(chat_req.message, chat_req.history, chat_req.provider, chat_req.model):
+        full_response = chunk
 
-    parts = [p for p in [connector_str, sys_str] if p]
-    full_system = "\n\n---\n\n".join(parts)
+    return JSONResponse(content={"response": full_response})
 
-    if full_system:
-        oai_messages.insert(0, {"role": "system", "content": full_system})
+@app.post("/chat/stream")
+async def chat_stream(request: Request, chat_req: ChatRequest):
+    verify_api_key(request)
 
-    # 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
-
-    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),
-    )
+    async def generate():
+        for chunk in ask(chat_req.message, chat_req.history, chat_req.provider, chat_req.model):
+            yield f"data: {json.dumps({'chunk': chunk})}\n\n"
+        yield "data: [DONE]\n\n"
 
-    client     = request.app.state.client
-    last_error = None
+    return StreamingResponse(generate(), media_type="text/event-stream")
 
-    for attempt in range(1, MAX_RETRIES + 1):
+@app.get("/providers")
+async def get_providers(request: Request):
+    verify_api_key(request)
 
-        try:
+    providers_info = {}
+    for pname, pobj in REAL_PROVIDERS.items():
+        if pname not in _PROVIDER_MODEL_CACHE:
+            _PROVIDER_MODEL_CACHE[pname] = discover_provider_models(pobj, pname)
+        providers_info[pname] = _PROVIDER_MODEL_CACHE[pname]
 
-            # ---------- STREAM ----------
-            if stream:
+    return JSONResponse(content={"providers": providers_info})
 
-                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],
-                    )
-                    last_error = raw_err
-                    await asyncio.sleep(RETRY_DELAY)
-                    continue
+# =====================================================
+# MCP / Claude-compatible endpoints
+# =====================================================
 
-                return StreamingResponse(
-                    stream_convert(resp, requested_model),
-                    media_type="text/event-stream",
-                    headers=STREAM_HEADERS,
-                )
-
-            # ---------- NORMAL ----------
-            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
-                )
-                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)
-            )
+@app.get("/v1/models")
+async def list_models(request: Request):
+    verify_api_key(request)
+    models = [
+        {"id": "claude-opus-4-6",   "object": "model", "owned_by": "anthropic"},
+        {"id": "claude-sonnet-4-6", "object": "model", "owned_by": "anthropic"},
+        {"id": "claude-haiku-4-5",  "object": "model", "owned_by": "anthropic"},
+    ]
+    return JSONResponse(content={"object": "list", "data": models})
 
-        except Exception as err:
-            last_error = str(err)
-            logger.exception("[%s] exception", req_id)
-            await asyncio.sleep(RETRY_DELAY)
+@app.post("/v1/messages")
+async def mcp_messages(request: Request):
+    verify_api_key(request)
+
+    body = await request.json()
+    model = body.get("model", "claude-sonnet-4-6")
+    messages = body.get("messages", [])
+    stream = body.get("stream", False)
+    max_tokens = body.get("max_tokens", 4096)
+
+    # استخراج آخر رسالة كـ message والباقي كـ history
+    if not messages:
+        raise HTTPException(status_code=400, detail="messages is required")
+
+    last_msg = messages[-1]
+    history = messages[:-1]
+
+    # دعم content كـ string أو list
+    if isinstance(last_msg.get("content"), list):
+        user_text = " ".join(
+            block.get("text", "")
+            for block in last_msg["content"]
+            if isinstance(block, dict) and block.get("type") == "text"
+        )
+    else:
+        user_text = last_msg.get("content", "")
+
+    if stream:
+        async def generate_stream():
+            full = ""
+            for chunk in ask(user_text, history, "Qwen", model):
+                delta = chunk[len(full):]
+                full = chunk
+                if delta:
+                    event = {
+                        "type": "content_block_delta",
+                        "delta": {"type": "text_delta", "text": delta}
+                    }
+                    yield f"data: {json.dumps(event)}\n\n"
+            yield f"data: {json.dumps({'type': 'message_stop'})}\n\n"
+
+        return StreamingResponse(generate_stream(), media_type="text/event-stream")
+
+    else:
+        full_response = ""
+        for chunk in ask(user_text, history, "Qwen", model):
+            full_response = chunk
+
+        return JSONResponse(content={
+            "id": f"msg_{int(time.time())}",
+            "type": "message",
+            "role": "assistant",
+            "model": model,
+            "content": [{"type": "text", "text": full_response}],
+            "stop_reason": "end_turn",
+            "usage": {"input_tokens": 0, "output_tokens": 0}
+        })
 
-    return JSONResponse(
-        status_code=502,
-        content={"error": "Upstream failed", "details": last_error},
-    )
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.getenv("PORT", "7860"))
+    uvicorn.run(app, host="0.0.0.0", port=port)