v2.0: curl_cffi Chrome TLS fingerprinting + upstream model migration

- Add curl_cffi for Chrome 124 TLS impersonation (fallback to urllib)
- Migrate model selection from integer mode to x-goog-ext hex ID headers
- Sync model IDs from upstream xwteam/gemini2api v1.6.15
- Add bracket-depth response frame scanner (replaces line-by-line parser)
- Add Chrome-like header ordering with Sec-Ch-Ua/Sec-Fetch-*
- Add request jitter (50-300ms) to mimic human behavior
- Stable public model names: gemini-pro, gemini-flash, gemini-flash-thinking
- 17 legacy model name aliases for backward compatibility
- Filter googleusercontent placeholder URLs from responses
- Update Dockerfile with libcurl4-openssl-dev for HF Spaces
- Add requirements.txt with curl_cffi==0.7.4

Dockerfile

@@ -1,12 +1,18 @@
-  FROM python:3.11-slim
+FROM python:3.11-slim
 
-  WORKDIR /app
+# System deps for curl_cffi (Chrome TLS fingerprint impersonation)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libcurl4-openssl-dev \
+    && apt-get clean && rm -rf /var/lib/apt/lists/*
 
-  # 项目本身零依赖(全用 Python 标准库),不需要 pip install
-  COPY gemini_web2api.py .
+WORKDIR /app
 
-  # HF Spaces 默认把外部流量路由到 7860
-  EXPOSE 7860
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
 
-  # 跑起来,host 默认就是 0.0.0.0
-  CMD ["python", "gemini_web2api.py", "--port", "7860"]
+COPY gemini_web2api.py .
+
+# HF Spaces routes external traffic to 7860
+EXPOSE 7860
+
+CMD ["python", "gemini_web2api.py", "--port", "7860"]

gemini_web2api.py

@@ -3,7 +3,7 @@
 gemini-web2api - Gemini Web to OpenAI API proxy.
 
 Converts Google Gemini's web interface into an OpenAI-compatible API server.
-Zero authentication required. Works on any platform (Windows/macOS/Linux).
+Uses curl_cffi for Chrome TLS fingerprint impersonation to avoid bot detection.
 
 Usage:
     python gemini_web2api.py [--port 8081] [--config config.json]
@@ -21,12 +21,26 @@ import sys
 import uuid
 import re
 import os
+import random
 import hashlib
 import argparse
 from http.server import HTTPServer, BaseHTTPRequestHandler
 from socketserver import ThreadingMixIn
+from collections import OrderedDict
 
-__version__ = "1.0.0"
+__version__ = "2.0.0"
+
+# ─── curl_cffi with fallback ────────────────────────────────────────────────
+# curl_cffi provides Chrome TLS fingerprint impersonation, making requests
+# indistinguishable from real Chrome browsers at the TLS layer.
+# Falls back to stdlib urllib if not available (less stealthy).
+
+try:
+    from curl_cffi.requests import Session as CurlSession
+    HAS_CURL_CFFI = True
+except ImportError:
+    HAS_CURL_CFFI = False
+    CurlSession = None
 
 # ─── Configuration ───────────────────────────────────────────────────────────
 
@@ -37,46 +51,139 @@ DEFAULT_CONFIG = {
     "retry_delay_sec": 2,
     "request_timeout_sec": 180,
     "gemini_bl": "boq_assistant-bard-web-server_20260525.09_p0",
-    "default_model": "gemini-3.5-flash",
+    "default_model": "gemini-flash",
     "log_requests": True,
     "cookie_file": None,
     "proxy": None,
     "api_key": os.environ.get("API_KEY"),  # Set via Hugging Face Secrets
+    # Chrome fingerprint settings
+    "chrome_version": 124,
+    "impersonate_target": "chrome124",
+    # Request jitter (ms) - randomized delays to mimic human behavior
+    "jitter_min_ms": 50,
+    "jitter_max_ms": 300,
 }
 
 CONFIG = dict(DEFAULT_CONFIG)
 
-# ─── Models ──────────────────────────────────────────────────────────────────
-# Mapping from JS source: MODE_CATEGORY enum (028-6eb337387583.js)
-#   1=FAST, 2=THINKING, 3=PRO, 4=AUTO, 5=FAST_DYNAMIC_THINKING, 6=FLASH_LITE
+# ─── Models (synced from upstream xwteam/gemini2api v1.6.15) ─────────────────
+# Model selection via x-goog-ext-525001261-jspb header with hex model IDs.
+# This replaces the old integer mode category approach.
 
-MODELS = {
-    "gemini-3.5-flash": {
-        "mode": 1, "think": 4,
-        "desc": "Fast general-purpose model",
+MODEL_HEADER_KEY = "x-goog-ext-525001261-jspb"
+
+GEMINI_MODELS = {
+    # Internal model name → routing info
+    "gemini-3-pro": {
+        "id": "9d8ca3786ebdfbea", "capacity": 1,
+        "desc": "Pro model (free tier)",
     },
-    "gemini-3.5-flash-thinking": {
-        "mode": 2, "think": 0,
-        "desc": "Deep thinking mode, longest output (~20k chars)",
+    "gemini-3-flash": {
+        "id": "fbb127bbb056c959", "capacity": 1,
+        "desc": "Fast general-purpose model",
     },
-    "gemini-3.1-pro": {
-        "mode": 3, "think": 4,
-        "desc": "Pro model (requires cookie for real routing)",
+    "gemini-3-flash-thinking": {
+        "id": "5bf011840784117a", "capacity": 1,
+        "desc": "Deep thinking mode",
     },
-    "gemini-auto": {
-        "mode": 4, "think": 4,
-        "desc": "Auto model selection",
+    # Pro-only (paid tier) models
+    "gemini-3-pro-plus": {
+        "id": "e6fa609c3fa255c0", "capacity": 4,
+        "desc": "Pro+ model (requires subscription)",
     },
-    "gemini-3.5-flash-thinking-lite": {
-        "mode": 5, "think": 0,
-        "desc": "Dynamic thinking with adaptive depth",
+    "gemini-3-flash-plus": {
+        "id": "56fdd199312815e2", "capacity": 4,
+        "desc": "Flash+ model (requires subscription)",
     },
-    "gemini-flash-lite": {
-        "mode": 6, "think": 4,
-        "desc": "Lightweight fast model",
+    "gemini-3-flash-thinking-plus": {
+        "id": "e051ce1aa80aa576", "capacity": 4,
+        "desc": "Thinking+ model (requires subscription)",
     },
 }
 
+# Stable public model names (API contract - never change these)
+# Maps public name → family → resolved to internal name
+PUBLIC_MODELS = {
+    "gemini-pro": {"family": "pro", "default": "gemini-3-pro",
+                   "desc": "Pro model for complex tasks"},
+    "gemini-flash": {"family": "flash", "default": "gemini-3-flash",
+                     "desc": "Fast general-purpose model"},
+    "gemini-flash-thinking": {"family": "flash-thinking", "default": "gemini-3-flash-thinking",
+                              "desc": "Deep thinking with extended output"},
+}
+
+# Legacy model name aliases → stable public name
+MODEL_ALIASES = {
+    # Old names from your v1.0.0
+    "gemini-3.5-flash": "gemini-flash",
+    "gemini-3.5-flash-thinking": "gemini-flash-thinking",
+    "gemini-3.5-flash-thinking-lite": "gemini-flash-thinking",
+    "gemini-3.1-pro": "gemini-pro",
+    "gemini-auto": "gemini-flash",
+    "gemini-flash-lite": "gemini-flash",
+    # Upstream aliases
+    "gemini-2.5-pro": "gemini-pro",
+    "gemini-2.5-flash": "gemini-flash",
+    "gemini-2.5-flash-thinking": "gemini-flash-thinking",
+    "gemini-2.5-pro-preview-05-06": "gemini-pro",
+    "gemini-2.5-flash-preview-04-17": "gemini-flash",
+    "gemini-2.5-flash-preview-05-20": "gemini-flash",
+    "gemini-2.0-flash": "gemini-flash",
+    "gemini-2.0-flash-thinking": "gemini-flash-thinking",
+    "gemini-2.0-flash-lite": "gemini-flash",
+    "gemini-1.5-pro": "gemini-pro",
+    "gemini-1.5-flash": "gemini-flash",
+}
+
+# All model names exposed to clients (public names only for API stability)
+EXPOSED_MODELS = PUBLIC_MODELS
+
+
+def resolve_model(model_name: str) -> tuple:
+    """Resolve any model name to (public_name, internal_name, model_info, error).
+
+    Resolution chain:
+      1. Legacy alias → public name
+      2. Public name → internal name (via family default)
+      3. Already an internal name → use directly
+    """
+    # Step 1: resolve aliases
+    name = MODEL_ALIASES.get(model_name, model_name)
+
+    # Step 2: if it's a public name, map to internal
+    if name in PUBLIC_MODELS:
+        pub = PUBLIC_MODELS[name]
+        internal = pub["default"]
+        info = GEMINI_MODELS.get(internal)
+        if not info:
+            return None, None, None, f"Internal model {internal} not found"
+        return name, internal, info, None
+
+    # Step 3: if it's already an internal name
+    if name in GEMINI_MODELS:
+        info = GEMINI_MODELS[name]
+        # Find the public name for this internal model
+        pub_name = name
+        for pn, pv in PUBLIC_MODELS.items():
+            if pv["default"] == name:
+                pub_name = pn
+                break
+        return pub_name, name, info, None
+
+    return None, None, None, f"Unknown model: {model_name}. Available: {', '.join(PUBLIC_MODELS.keys())}"
+
+
+def build_model_headers(model_info: dict) -> dict:
+    """Build the x-goog-ext headers for model selection."""
+    if not model_info:
+        return {}
+    return {
+        MODEL_HEADER_KEY: f'[1,null,null,null,"{model_info["id"]}",null,null,0,[4],null,null,{model_info["capacity"]}]',
+        "x-goog-ext-73010989-jspb": "[0]",
+        "x-goog-ext-73010990-jspb": "[0]",
+    }
+
+
 # ─── Utilities ───────────────────────────────────────────────────────────────
 
 def log(msg: str):
@@ -85,6 +192,12 @@ def log(msg: str):
         sys.stderr.flush()
 
 
+def apply_jitter():
+    """Random delay to mimic human behavior."""
+    delay = random.uniform(CONFIG["jitter_min_ms"], CONFIG["jitter_max_ms"]) / 1000.0
+    time.sleep(delay)
+
+
 def load_cookie() -> tuple:
     """Load cookie from file. Returns (cookie_str, sapisid)."""
     cookie_file = CONFIG.get("cookie_file")
@@ -115,10 +228,160 @@ def make_sapisidhash(sapisid: str) -> str:
     return f"SAPISIDHASH {ts}_{h}"
 
 
+# ─── Chrome-like Request Headers ─────────────────────────────────────────────
+
+def build_chrome_headers(method: str = "POST", content_type: str = None) -> OrderedDict:
+    """Build Chrome-like request headers in the correct order.
+
+    Chrome sends headers in a specific order that differs from Python defaults.
+    Matching this order helps avoid fingerprint-based detection.
+    """
+    ver = CONFIG["chrome_version"]
+    headers = OrderedDict()
+
+    # Chrome header order (important for fingerprint matching)
+    headers["Host"] = "gemini.google.com"
+
+    if content_type:
+        headers["Content-Type"] = content_type
+
+    headers["Sec-Ch-Ua"] = f'"Chromium";v="{ver}", "Google Chrome";v="{ver}", "Not-A.Brand";v="99"'
+    headers["Sec-Ch-Ua-Mobile"] = "?0"
+    headers["Sec-Ch-Ua-Platform"] = '"Windows"'
+
+    headers["User-Agent"] = (
+        f"Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+        f"AppleWebKit/537.36 (KHTML, like Gecko) "
+        f"Chrome/{ver}.0.0.0 Safari/537.36"
+    )
+
+    headers["X-Same-Domain"] = "1"
+    headers["Origin"] = "https://gemini.google.com"
+    headers["Referer"] = "https://gemini.google.com/app"
+
+    # Sec-Fetch headers (differ by method)
+    if method == "POST":
+        headers["Sec-Fetch-Site"] = "same-origin"
+        headers["Sec-Fetch-Mode"] = "cors"
+        headers["Sec-Fetch-Dest"] = "empty"
+    else:
+        headers["Sec-Fetch-Site"] = "same-origin"
+        headers["Sec-Fetch-Mode"] = "navigate"
+        headers["Sec-Fetch-Dest"] = "document"
+        headers["Sec-Fetch-User"] = "?1"
+
+    headers["Accept-Language"] = "en-US,en;q=0.9"
+    headers["Accept"] = "*/*"
+
+    return headers
+
+
+# ─── HTTP Transport Layer ─────��──────────────────────────────────────────────
+
+class GeminiHTTPClient:
+    """HTTP client with Chrome TLS fingerprint impersonation.
+
+    Uses curl_cffi when available for real Chrome TLS fingerprints.
+    Falls back to urllib.request (less stealthy but functional).
+    """
+
+    def __init__(self):
+        self._session = None
+        if HAS_CURL_CFFI:
+            target = CONFIG.get("impersonate_target", "chrome124")
+            self._session = CurlSession(
+                impersonate=target,
+                timeout=CONFIG["request_timeout_sec"],
+            )
+            log(f"HTTP transport: curl_cffi (impersonating {target})")
+        else:
+            log("HTTP transport: urllib (no TLS fingerprinting - less stealthy)")
+
+    def post(self, url: str, data: bytes, headers: dict, cookies: dict = None) -> str:
+        """POST request with Chrome fingerprint. Returns response text."""
+        if self._session:
+            return self._post_curl(url, data, headers, cookies)
+        else:
+            return self._post_urllib(url, data, headers, cookies)
+
+    def _post_curl(self, url: str, data: bytes, headers: dict, cookies: dict = None) -> str:
+        """POST via curl_cffi with Chrome TLS impersonation."""
+        # Clear internal cookie jar to prevent cross-domain cookie conflicts
+        # (same fix as upstream: google.com / gemini.google.com / accounts.google.com)
+        self._session.cookies.clear()
+
+        proxy = CONFIG.get("proxy")
+        proxies = {"http": proxy, "https": proxy} if proxy else None
+
+        resp = self._session.post(
+            url,
+            data=data,
+            headers=dict(headers),  # curl_cffi needs plain dict
+            cookies=cookies or {},
+            proxies=proxies,
+            allow_redirects=True,
+        )
+
+        if resp.status_code != 200:
+            raise Exception(f"HTTP {resp.status_code}: {resp.text[:200]}")
+
+        return resp.text
+
+    def _post_urllib(self, url: str, data: bytes, headers: dict, cookies: dict = None) -> str:
+        """Fallback POST via urllib (no TLS fingerprinting)."""
+        # Merge cookies into headers
+        all_headers = dict(headers)
+        if cookies:
+            cookie_str = "; ".join(f"{k}={v}" for k, v in cookies.items())
+            existing = all_headers.get("Cookie", "")
+            if existing:
+                all_headers["Cookie"] = existing + "; " + cookie_str
+            else:
+                all_headers["Cookie"] = cookie_str
+
+        req = urllib.request.Request(url, data=data, headers=all_headers, method="POST")
+        ctx = ssl.create_default_context()
+        proxy = CONFIG.get("proxy")
+        if proxy:
+            opener = urllib.request.build_opener(
+                urllib.request.ProxyHandler({"http": proxy, "https": proxy}),
+                urllib.request.HTTPSHandler(context=ctx)
+            )
+            resp = opener.open(req, timeout=CONFIG["request_timeout_sec"])
+        else:
+            resp = urllib.request.urlopen(req, context=ctx, timeout=CONFIG["request_timeout_sec"])
+
+        return resp.read().decode("utf-8", errors="replace")
+
+    def close(self):
+        if self._session:
+            try:
+                self._session.close()
+            except Exception:
+                pass
+
+
+# Global HTTP client (initialized in main)
+_http_client: GeminiHTTPClient = None
+
+
+def get_http_client() -> GeminiHTTPClient:
+    global _http_client
+    if _http_client is None:
+        _http_client = GeminiHTTPClient()
+    return _http_client
+
+
 # ─── Gemini Protocol ─────────────────────────────────────────────────────────
 
-def gemini_stream_generate(prompt: str, model_id: int, think_mode: int) -> str:
-    """Send prompt to Gemini StreamGenerate with retry."""
+def gemini_stream_generate(prompt: str, model_info: dict) -> str:
+    """Send prompt to Gemini StreamGenerate with retry.
+
+    Uses the x-goog-ext-525001261-jspb header for model selection
+    (upstream approach) instead of the old integer mode category.
+    """
+    # Build the inner payload array
+    # The payload structure is from Gemini's batchexecute protocol
     inner = [None] * 80
     inner[0] = [prompt, 0, None, None, None, None, 0]
     inner[1] = ["en"]
@@ -127,7 +390,9 @@ def gemini_stream_generate(prompt: str, model_id: int, think_mode: int) -> str:
     inner[7] = 1
     inner[10] = 1
     inner[11] = 0
-    inner[17] = [[think_mode]]
+    # Think mode: 0 = thinking enabled, 4 = thinking disabled
+    # For thinking models, we enable thinking; for others, disable
+    inner[17] = [[0]]  # Default: thinking enabled
     inner[18] = 0
     inner[27] = 1
     inner[30] = [4]
@@ -136,76 +401,143 @@ def gemini_stream_generate(prompt: str, model_id: int, think_mode: int) -> str:
     inner[59] = str(uuid.uuid4())
     inner[61] = []
     inner[68] = 1
-    inner[79] = model_id
+    # Model is now set via HTTP header, not payload slot 79
+    # inner[79] is left as None
 
     outer = [None, json.dumps(inner)]
     body = urllib.parse.urlencode({"f.req": json.dumps(outer)}).encode()
-    reqid = int(time.time()) % 1000000
+    reqid = random.randint(10000, 99999)
     url = (
         "https://gemini.google.com/_/BardChatUi/data/"
         "assistant.lamda.BardFrontendService/StreamGenerate"
         f"?bl={CONFIG['gemini_bl']}&hl=en&_reqid={reqid}&rt=c"
     )
-    headers = {
-        "Content-Type": "application/x-www-form-urlencoded",
-        "Origin": "https://gemini.google.com",
-        "Referer": "https://gemini.google.com/app",
-        "X-Same-Domain": "1",
-        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
-    }
 
+    # Build Chrome-like headers
+    headers = build_chrome_headers(
+        method="POST",
+        content_type="application/x-www-form-urlencoded",
+    )
+
+    # Add model selection headers
+    model_headers = build_model_headers(model_info)
+    headers.update(model_headers)
+
+    # Load and apply cookie
     cookie_str, sapisid = load_cookie()
+    cookies = {}
     if cookie_str:
+        # Parse cookie string into dict for curl_cffi
+        for pair in cookie_str.split("; "):
+            if "=" in pair:
+                k, v = pair.split("=", 1)
+                cookies[k.strip()] = v.strip()
+        # Also set as header for urllib fallback
         headers["Cookie"] = cookie_str
     if sapisid:
         headers["Authorization"] = make_sapisidhash(sapisid)
 
+    client = get_http_client()
     last_err = None
     for attempt in range(CONFIG["retry_attempts"]):
         try:
-            req = urllib.request.Request(url, data=body, headers=headers, method="POST")
-            ctx = ssl.create_default_context()
-            proxy = CONFIG.get("proxy")
-            if proxy:
-                opener = urllib.request.build_opener(
-                    urllib.request.ProxyHandler({"http": proxy, "https": proxy}),
-                    urllib.request.HTTPSHandler(context=ctx)
-                )
-                resp = opener.open(req, timeout=CONFIG["request_timeout_sec"])
-            else:
-                resp = urllib.request.urlopen(req, context=ctx, timeout=CONFIG["request_timeout_sec"])
-            return resp.read().decode("utf-8", errors="replace")
+            # Apply request jitter to mimic human behavior
+            if attempt > 0:
+                time.sleep(CONFIG["retry_delay_sec"])
+            apply_jitter()
+
+            return client.post(url, data=body, headers=headers, cookies=cookies)
         except Exception as e:
             last_err = e
             if attempt < CONFIG["retry_attempts"] - 1:
                 log(f"Retry {attempt+1}/{CONFIG['retry_attempts']}: {e}")
-                time.sleep(CONFIG["retry_delay_sec"])
     raise last_err
 
 
 def clean_gemini_text(text: str) -> str:
-    """Remove internal code execution artifacts."""
+    """Remove internal code execution artifacts and image placeholders."""
+    # Remove code execution artifacts
     text = re.sub(
         r'```(?:python|javascript|text)\?code_(?:reference|stdout)&code_event_index=\d+\n.*?```\n?',
         '', text, flags=re.DOTALL
     )
+    # Remove googleusercontent placeholder URLs (image gen/retrieval/collection)
+    text = re.sub(
+        r'https?://googleusercontent\.com/(?:image_generation_content|image_retrieval|image_collection)[/\w]*\d*',
+        '', text
+    )
     return text.strip()
 
 
+def _scan_complete_wrb_frames(buf: str) -> list:
+    """Extract complete wrb.fr frames using bracket-depth scanning.
+
+    This is the upstream's improved parser that correctly handles
+    partial chunks and escape sequences, replacing the old line-by-line approach.
+    """
+    frames = []
+    i = 0
+    n = len(buf)
+    while i < n:
+        start = buf.find('["wrb.fr"', i)
+        if start == -1:
+            break
+        # Bracket-depth scan to find matching close bracket
+        depth = 0
+        in_str = False
+        esc = False
+        end = -1
+        j = start
+        while j < n:
+            c = buf[j]
+            if in_str:
+                if esc:
+                    esc = False
+                elif c == '\\':
+                    esc = True
+                elif c == '"':
+                    in_str = False
+            else:
+                if c == '"':
+                    in_str = True
+                elif c == '[':
+                    depth += 1
+                elif c == ']':
+                    depth -= 1
+                    if depth == 0:
+                        end = j
+                        break
+            j += 1
+        if end == -1:
+            break  # Incomplete frame
+        elem_str = buf[start:end + 1]
+        try:
+            elem = json.loads(elem_str)
+            frames.append(elem)
+        except (json.JSONDecodeError, ValueError):
+            pass
+        i = end + 1
+    return frames
+
+
 def extract_response_text(raw: str) -> str:
-    """Parse StreamGenerate response to extract final text."""
+    """Parse StreamGenerate response to extract final text.
+
+    Uses the upstream's bracket-depth frame scanner for robustness.
+    """
+    frames = _scan_complete_wrb_frames(raw)
+
     texts = []
-    for line in raw.split("\n"):
-        if '"wrb.fr"' not in line or len(line) < 200:
-            continue
+    for elem in frames:
         try:
-            arr = json.loads(line)
-            inner_str = arr[0][2]
-            if not inner_str or len(inner_str) < 50:
+            if not isinstance(elem, list) or len(elem) < 3 or elem[0] != "wrb.fr":
+                continue
+            rp = elem[2]
+            if not isinstance(rp, str) or len(rp) < 50:
                 continue
-            inner = json.loads(inner_str)
-            if isinstance(inner, list) and len(inner) > 4 and inner[4]:
-                for part in inner[4]:
+            payload = json.loads(rp)
+            if isinstance(payload, list) and len(payload) > 4 and payload[4]:
+                for part in payload[4]:
                     if isinstance(part, list) and len(part) > 1 and part[1]:
                         if isinstance(part[1], list):
                             for t in part[1]:
@@ -213,6 +545,8 @@ def extract_response_text(raw: str) -> str:
                                     texts.append(t)
         except (json.JSONDecodeError, IndexError, TypeError):
             pass
+
+    # Take the last non-empty text (final/most complete response)
     text = ""
     for t in reversed(texts):
         if t.strip():
@@ -260,7 +594,7 @@ def messages_to_prompt(messages: list, tools: list = None) -> str:
                     fn = tc.get("function", {})
                     tc_strs.append(
                         f'```tool_call\n{{"name": "{fn.get("name")}", '
-                        f'"arguments": {fn.get("arguments", "{}")}}}\n```'
+                        f'"arguments": {fn.get("arguments", "{}}")}}}\n```'
                     )
                 parts.append(f"[Assistant]: {content or ''}\n" + "\n".join(tc_strs))
             else:
@@ -342,11 +676,16 @@ class GeminiHandler(BaseHTTPRequestHandler):
                 self.send_json({"object": "list", "data": [
                     {"id": n, "object": "model", "created": 1700000000,
                      "owned_by": "google", "description": c["desc"]}
-                    for n, c in MODELS.items()
+                    for n, c in EXPOSED_MODELS.items()
                 ]})
             elif self.path == "/":
-                self.send_json({"status": "ok", "version": __version__,
-                                "models": list(MODELS.keys())})
+                self.send_json({
+                    "status": "ok",
+                    "version": __version__,
+                    "transport": "curl_cffi" if HAS_CURL_CFFI else "urllib",
+                    "models": list(EXPOSED_MODELS.keys()),
+                    "aliases": list(MODEL_ALIASES.keys()),
+                })
             else:
                 self.send_json({"error": "not found"}, 404)
         except (BrokenPipeError, ConnectionResetError):
@@ -376,17 +715,13 @@ class GeminiHandler(BaseHTTPRequestHandler):
                 pass
 
     def _resolve_model(self, model_name):
-        think_override = None
-        if "@think=" in model_name:
-            model_name, think_str = model_name.rsplit("@think=", 1)
-            think_override = int(think_str)
-        cfg = MODELS.get(model_name)
-        if not cfg:
-            return None, None, None, f"Unknown model: {model_name}"
-        return model_name, cfg["mode"], (think_override if think_override is not None else cfg["think"]), None
-
-    def _call_gemini(self, prompt, model_id, think_mode, tools):
-        raw = gemini_stream_generate(prompt, model_id, think_mode)
+        pub_name, internal_name, model_info, err = resolve_model(model_name)
+        if err:
+            return None, None, err
+        return pub_name, model_info, None
+
+    def _call_gemini(self, prompt, model_info, tools):
+        raw = gemini_stream_generate(prompt, model_info)
         text = extract_response_text(raw)
         tool_calls = None
         if tools and text:
@@ -395,7 +730,7 @@ class GeminiHandler(BaseHTTPRequestHandler):
 
     def handle_chat(self, body: bytes):
         req = json.loads(body)
-        model_name, model_id, think_mode, err = self._resolve_model(
+        model_name, model_info, err = self._resolve_model(
             req.get("model", CONFIG["default_model"]))
         if err:
             self.send_json({"error": {"message": err}}, 400)
@@ -408,7 +743,7 @@ class GeminiHandler(BaseHTTPRequestHandler):
             return
 
         try:
-            text, tool_calls = self._call_gemini(prompt, model_id, think_mode, tools)
+            text, tool_calls = self._call_gemini(prompt, model_info, tools)
         except Exception as e:
             self.send_json({"error": {"message": f"upstream error: {e}"}}, 502)
             return
@@ -442,7 +777,7 @@ class GeminiHandler(BaseHTTPRequestHandler):
     def handle_responses(self, body: bytes):
         """OpenAI Responses API for Codex CLI compatibility."""
         req = json.loads(body)
-        model_name, model_id, think_mode, err = self._resolve_model(
+        model_name, model_info, err = self._resolve_model(
             req.get("model", CONFIG["default_model"]))
         if err:
             self.send_json({"error": {"message": err}}, 400)
@@ -497,7 +832,7 @@ class GeminiHandler(BaseHTTPRequestHandler):
             return
 
         try:
-            text, tool_calls = self._call_gemini(prompt, model_id, think_mode, tools)
+            text, tool_calls = self._call_gemini(prompt, model_info, tools)
         except Exception as e:
             self.send_json({"error": {"message": f"upstream error: {e}"}}, 502)
             return
@@ -572,6 +907,9 @@ def main():
     if args.proxy:
         CONFIG["proxy"] = args.proxy
 
+    # Initialize HTTP client
+    get_http_client()
+
     class ThreadedServer(ThreadingMixIn, HTTPServer):
         daemon_threads = True
         allow_reuse_address = True
@@ -581,16 +919,20 @@ def main():
     print(f"gemini-web2api v{__version__}")
     print(f"  Listening: http://0.0.0.0:{port}")
     print(f"  Base URL:  http://localhost:{port}/v1")
-    print(f"  Models:    {', '.join(MODELS.keys())}")
+    print(f"  Transport: {'curl_cffi (Chrome TLS fingerprint)' if HAS_CURL_CFFI else 'urllib (no fingerprint - install curl_cffi for stealth)'}")
+    print(f"  Models:    {', '.join(EXPOSED_MODELS.keys())}")
+    print(f"  Aliases:   {len(MODEL_ALIASES)} legacy names supported")
     print(f"  API Key:   {'configured (set via API_KEY env)' if CONFIG.get('api_key') else 'none (open access)'}")
     print(f"  Cookie:    {'yes (' + CONFIG['cookie_file'] + ')' if CONFIG.get('cookie_file') else 'none (anonymous)'}")
     print(f"  Proxy:     {CONFIG.get('proxy') or 'none (uses system env HTTP_PROXY/HTTPS_PROXY)'}")
     print(f"  Retry:     {CONFIG['retry_attempts']}x / {CONFIG['retry_delay_sec']}s")
+    print(f"  Jitter:    {CONFIG['jitter_min_ms']}-{CONFIG['jitter_max_ms']}ms")
     print()
     try:
         server.serve_forever()
     except KeyboardInterrupt:
         print("\nStopped.")
+        get_http_client().close()
         server.shutdown()
 
 

requirements.txt

@@ -0,0 +1 @@
+curl_cffi==0.7.4