Upload 8 files

.dockerignore

@@ -0,0 +1,10 @@
+.git
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.log
+.env
+.venv/
+venv/
+node_modules/

Dockerfile

@@ -0,0 +1,66 @@
+FROM python:3.11-slim
+
+ENV DEBIAN_FRONTEND=noninteractive \
+    PIP_NO_CACHE_DIR=1 \
+    PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PLAYWRIGHT_BROWSERS_PATH=/ms-playwright \
+    PORT=7860 \
+    HOST=0.0.0.0
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    xvfb \
+    curl \
+    ca-certificates \
+    fonts-liberation \
+    libasound2 \
+    libatk-bridge2.0-0 \
+    libatk1.0-0 \
+    libc6 \
+    libcairo2 \
+    libcups2 \
+    libdbus-1-3 \
+    libdrm2 \
+    libexpat1 \
+    libfontconfig1 \
+    libgbm1 \
+    libgcc1 \
+    libglib2.0-0 \
+    libgtk-3-0 \
+    libnspr4 \
+    libnss3 \
+    libpango-1.0-0 \
+    libpangocairo-1.0-0 \
+    libstdc++6 \
+    libx11-6 \
+    libx11-xcb1 \
+    libxcb1 \
+    libxcomposite1 \
+    libxdamage1 \
+    libxext6 \
+    libxfixes3 \
+    libxrandr2 \
+    libxrender1 \
+    libxshmfence1 \
+    libxkbcommon0 \
+    libxss1 \
+    libxtst6 \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+WORKDIR $HOME/app
+
+COPY --chown=user requirements.txt ./requirements.txt
+RUN pip install --upgrade pip && \
+    pip install -r requirements.txt && \
+    pip install pyvirtualdisplay && \
+    playwright install chromium
+
+COPY --chown=user . $HOME/app
+
+EXPOSE 7860
+CMD ["python", "server.py"]

config.json

@@ -0,0 +1,10 @@
+{
+    "api_key": "sk-duck-ai",
+    "host": "0.0.0.0",
+    "port": 8787,
+    "default_model": "claude-haiku-4-5",
+    "assistant_name": null,
+    "system_prompt": null,
+    "web_search": true,
+    "proxy": null
+}

duck_client.py

@@ -0,0 +1,519 @@
+import json
+import uuid
+import base64
+import asyncio
+import logging
+import os
+import sys
+import time
+from typing import AsyncIterator, Optional
+
+from playwright.async_api import async_playwright, Browser, BrowserContext, Page, Route
+from cryptography.hazmat.primitives.asymmetric import rsa, padding
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.backends import default_backend
+
+logger = logging.getLogger(__name__)
+
+_virtual_display = None
+
+
+def _ensure_display():
+    """On Linux without DISPLAY, start a virtual display via Xvfb."""
+    global _virtual_display
+    if _virtual_display is not None:
+        return
+    if sys.platform != "linux":
+        return  # Windows/macOS always have a display
+    if os.environ.get("DISPLAY"):
+        return  # Display already available
+    try:
+        from pyvirtualdisplay import Display
+        _virtual_display = Display(visible=False, size=(1280, 800))
+        _virtual_display.start()
+        logger.info(f"Started virtual display: {os.environ.get('DISPLAY')}")
+    except ImportError:
+        logger.warning(
+            "No DISPLAY and pyvirtualdisplay not installed. "
+            "Install with: pip install pyvirtualdisplay\n"
+            "Also install Xvfb: apt-get install xvfb"
+        )
+        raise RuntimeError(
+            "Headless server requires pyvirtualdisplay + xvfb. "
+            "Install: pip install pyvirtualdisplay && apt-get install xvfb"
+        )
+
+DUCK_AI_BASE = "https://duck.ai"
+CHAT_URL_PATTERN = "**/duckchat/v1/chat"
+SEC_CH_UA = '"Not:A-Brand";v="99", "Google Chrome";v="133", "Chromium";v="133"'
+USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36"
+
+DEFAULT_POOL_SIZE = 3
+
+
+def _int_to_base64url(n: int, length: int = None) -> str:
+    b = n.to_bytes((n.bit_length() + 7) // 8, byteorder='big') if n > 0 else b'\x00'
+    if length and len(b) < length:
+        b = b'\x00' * (length - len(b)) + b
+    return base64.urlsafe_b64encode(b).rstrip(b'=').decode('ascii')
+
+
+def _rsa_public_key_to_jwk(public_key) -> dict:
+    pub_numbers = public_key.public_numbers()
+    n_bytes = (pub_numbers.n.bit_length() + 7) // 8
+    return {
+        "alg": "RSA-OAEP-256",
+        "e": _int_to_base64url(pub_numbers.e),
+        "ext": True,
+        "key_ops": ["encrypt"],
+        "kty": "RSA",
+        "n": _int_to_base64url(pub_numbers.n, n_bytes),
+        "use": "enc"
+    }
+
+
+def _generate_rsa_keypair():
+    priv = rsa.generate_private_key(
+        public_exponent=65537, key_size=2048, backend=default_backend()
+    )
+    jwk = _rsa_public_key_to_jwk(priv.public_key())
+    return priv, jwk
+
+
+def _decrypt_data(private_key, encrypted_b64: str) -> Optional[str]:
+    if not private_key:
+        return None
+    try:
+        raw = base64.b64decode(encrypted_b64)
+        enc_key = raw[:256]
+        rest = raw[256:]
+        aes_key = private_key.decrypt(
+            enc_key,
+            padding.OAEP(mgf=padding.MGF1(algorithm=hashes.SHA256()),
+                         algorithm=hashes.SHA256(), label=None)
+        )
+        iv, tag, ct = rest[:12], rest[-16:], rest[12:-16]
+        cipher = Cipher(algorithms.AES(aes_key), modes.GCM(iv, tag), backend=default_backend())
+        dec = cipher.decryptor()
+        return (dec.update(ct) + dec.finalize()).decode('utf-8')
+    except Exception as e:
+        logger.debug(f"Decryption failed: {e}")
+        return None
+
+
+# ---------------------------------------------------------------------------
+# PageWorker: one browser tab that can handle one chat request at a time
+# ---------------------------------------------------------------------------
+class PageWorker:
+    def __init__(self, worker_id: int, context: BrowserContext):
+        self.id = worker_id
+        self._context = context
+        self.page: Optional[Page] = None
+        self.ready = False
+        self.request_count = 0
+
+    async def init(self):
+        """Create page, navigate to duck.ai, handle first-visit dialog."""
+        self.page = await self._context.new_page()
+        await self.page.goto(DUCK_AI_BASE, wait_until="domcontentloaded", timeout=60000)
+        await self.page.wait_for_timeout(3000)
+
+        for selector in [
+            "button:has-text('Get Started')",
+            "button:has-text('Continue')",
+            "button:has-text('I Agree')",
+            "button:has-text('Accept')",
+        ]:
+            try:
+                btn = self.page.locator(selector)
+                if await btn.count() > 0:
+                    await btn.first.click(timeout=3000)
+                    await self.page.wait_for_timeout(1000)
+            except:
+                pass
+
+        try:
+            await self.page.wait_for_selector("textarea:not([disabled])", timeout=15000)
+        except:
+            logger.warning(f"Worker {self.id}: textarea not enabled after 15s")
+
+        self.ready = True
+        logger.info(f"Worker {self.id} ready")
+
+    async def reinit(self):
+        """Recreate the page (e.g. after an error)."""
+        try:
+            if self.page:
+                await self.page.close()
+        except:
+            pass
+        self.page = None
+        self.ready = False
+        await self.init()
+
+    async def do_chat(self, desired_body: dict, private_key, public_key_jwk) -> str:
+        """
+        Send a chat request through the page's own UI flow with route interception.
+        Returns the raw SSE response body text.
+        """
+        response_data = {"body": None, "status": None, "error": None}
+
+        async def intercept_chat(route: Route):
+            try:
+                request = route.request
+                original_body = json.loads(request.post_data) if request.post_data else {}
+                durable = original_body.get("durableStream", {})
+                durable["publicKey"] = public_key_jwk
+                final_body = {**desired_body, "durableStream": durable}
+
+                resp = await route.fetch(post_data=json.dumps(final_body))
+                body_bytes = await resp.body()
+                response_data["status"] = resp.status
+                response_data["body"] = body_bytes.decode("utf-8", errors="replace")
+
+                await route.fulfill(
+                    status=200,
+                    content_type="text/event-stream",
+                    body='data: {"action":"success"}\n\ndata: [DONE]\n\n'
+                )
+            except Exception as e:
+                response_data["error"] = str(e)
+                logger.error(f"Worker {self.id} intercept error: {e}")
+                try:
+                    await route.fulfill(status=200, content_type="text/event-stream",
+                                        body='data: [DONE]\n\n')
+                except:
+                    pass
+
+        # Click "New Chat" if available
+        try:
+            nc = self.page.locator("a:has-text('New Chat'), button:has-text('New Chat'), a[href='/']")
+            if await nc.count() > 0:
+                await nc.first.click(timeout=3000)
+                await self.page.wait_for_timeout(1000)
+        except:
+            pass
+
+        # Ensure textarea
+        try:
+            await self.page.wait_for_selector("textarea:not([disabled])", timeout=10000)
+        except:
+            await self.reinit()
+            await self.page.wait_for_selector("textarea:not([disabled])", timeout=10000)
+
+        await self.page.route(CHAT_URL_PATTERN, intercept_chat)
+
+        max_retries = 2
+        for attempt in range(max_retries + 1):
+            response_data = {"body": None, "status": None, "error": None}
+
+            try:
+                textarea = self.page.locator("textarea:not([disabled])")
+                await textarea.first.click(timeout=5000)
+                msgs = desired_body.get("messages", [])
+                last_msg = msgs[-1]["content"] if msgs else "Hi"
+                await textarea.first.fill(last_msg[:50])
+                await self.page.wait_for_timeout(200)
+                await textarea.first.press("Enter")
+
+                for _ in range(120):
+                    await self.page.wait_for_timeout(500)
+                    if response_data["body"] is not None or response_data["error"] is not None:
+                        break
+            except Exception as e:
+                response_data["error"] = str(e)
+
+            try:
+                await self.page.unroute(CHAT_URL_PATTERN, intercept_chat)
+            except:
+                pass
+
+            if response_data["error"]:
+                logger.error(f"Worker {self.id} attempt {attempt+1}: {response_data['error']}")
+                if attempt < max_retries:
+                    await self.reinit()
+                    await self.page.route(CHAT_URL_PATTERN, intercept_chat)
+                    continue
+                raise RuntimeError(f"Chat failed: {response_data['error']}")
+
+            status = response_data.get("status", 0)
+            body = response_data.get("body", "")
+
+            if status == 429 or (status == 418 and "ERR_BN_LIMIT" in body):
+                if attempt < max_retries:
+                    logger.warning(f"Worker {self.id} rate limited, retrying...")
+                    await asyncio.sleep(5)
+                    await self.reinit()
+                    await self.page.route(CHAT_URL_PATTERN, intercept_chat)
+                    continue
+                raise RuntimeError(f"Rate limited: {body[:200]}")
+
+            if status != 200:
+                if attempt < max_retries:
+                    logger.warning(f"Worker {self.id} error {status}, retrying...")
+                    await self.reinit()
+                    await self.page.route(CHAT_URL_PATTERN, intercept_chat)
+                    continue
+                raise RuntimeError(f"Chat API error {status}: {body[:300]}")
+
+            self.request_count += 1
+            return body
+
+        raise RuntimeError("Exhausted retries")
+
+    async def close(self):
+        try:
+            if self.page:
+                await self.page.close()
+        except:
+            pass
+
+
+# ---------------------------------------------------------------------------
+# DuckAIClient: manages browser + pool of PageWorkers
+# ---------------------------------------------------------------------------
+class DuckAIClient:
+    def __init__(self, proxy: str = None, model: str = "claude-haiku-4-5",
+                 assistant_name: str = None, system_prompt: str = None,
+                 pool_size: int = DEFAULT_POOL_SIZE):
+        self.model = model
+        self.assistant_name = assistant_name
+        self.system_prompt = system_prompt
+        self.proxy = proxy
+        self.pool_size = pool_size
+        self._playwright = None
+        self._browser: Optional[Browser] = None
+        self._context: Optional[BrowserContext] = None
+        self._pool: Optional[asyncio.Queue] = None
+        self._workers: list[PageWorker] = []
+        self._init_lock = asyncio.Lock()
+        self._ready = False
+
+    async def _ensure_ready(self):
+        if self._ready:
+            return
+        async with self._init_lock:
+            if self._ready:
+                return
+            _ensure_display()
+            logger.info(f"Launching browser (pool_size={self.pool_size})...")
+            self._playwright = await async_playwright().start()
+
+            launch_args = {
+                "headless": False,
+                "args": [
+                    "--disable-blink-features=AutomationControlled",
+                    "--window-position=-9999,-9999",
+                    "--no-sandbox",
+                ],
+            }
+            self._browser = await self._playwright.chromium.launch(**launch_args)
+
+            ctx_args = {
+                "user_agent": USER_AGENT,
+                "viewport": {"width": 1280, "height": 800},
+                "locale": "en-US",
+            }
+            if self.proxy:
+                ctx_args["proxy"] = {"server": self.proxy}
+            self._context = await self._browser.new_context(**ctx_args)
+            await self._context.set_extra_http_headers({"sec-ch-ua": SEC_CH_UA})
+
+            # Create page workers
+            self._pool = asyncio.Queue()
+            self._workers = []
+            init_tasks = []
+            for i in range(self.pool_size):
+                w = PageWorker(i, self._context)
+                self._workers.append(w)
+                init_tasks.append(w.init())
+
+            # Initialize all workers in parallel
+            results = await asyncio.gather(*init_tasks, return_exceptions=True)
+            for i, res in enumerate(results):
+                if isinstance(res, Exception):
+                    logger.error(f"Worker {i} init failed: {res}")
+                else:
+                    self._pool.put_nowait(self._workers[i])
+
+            ready_count = self._pool.qsize()
+            logger.info(f"Browser ready: {ready_count}/{self.pool_size} workers")
+            if ready_count == 0:
+                raise RuntimeError("No workers initialized successfully")
+            self._ready = True
+
+    async def chat_stream(self, messages: list, web_search: bool = True,
+                          custom_instructions: str = None,
+                          assistant_name: str = None) -> AsyncIterator[dict]:
+        await self._ensure_ready()
+
+        # Build desired body
+        duck_messages = []
+        metadata = {}
+        name = assistant_name or self.assistant_name
+
+        if name or custom_instructions:
+            customization = {}
+            if name:
+                customization["assistantName"] = name
+            customization["shouldSeekClarity"] = False
+            if custom_instructions:
+                customization["customInstructions"] = custom_instructions
+            metadata["customization"] = customization
+
+        metadata["toolChoice"] = {
+            "WebSearch": web_search, "NewsSearch": False,
+            "VideosSearch": False, "LocalSearch": False, "WeatherForecast": False
+        }
+
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+            if role == "system":
+                metadata.setdefault("customization", {})["customInstructions"] = content
+                continue
+            duck_messages.append({
+                "role": "assistant" if role == "assistant" else "user",
+                "content": content
+            })
+
+        if not duck_messages:
+            duck_messages = [{"role": "user", "content": "Hello"}]
+
+        desired_body = {
+            "model": self.model,
+            "messages": duck_messages,
+            "canUseTools": web_search,
+            "canUseApproxLocation": None,
+        }
+        if metadata:
+            desired_body["metadata"] = metadata
+
+        # Generate per-request RSA keypair
+        private_key, public_key_jwk = _generate_rsa_keypair()
+
+        # Acquire a worker from the pool (blocks if all busy)
+        worker: PageWorker = await asyncio.wait_for(self._pool.get(), timeout=120)
+        try:
+            t0 = time.time()
+            raw_body = await worker.do_chat(desired_body, private_key, public_key_jwk)
+            elapsed = time.time() - t0
+            logger.info(f"Worker {worker.id} completed in {elapsed:.1f}s "
+                        f"(total: {worker.request_count})")
+        except Exception as e:
+            # Return worker even on failure
+            self._pool.put_nowait(worker)
+            raise
+        else:
+            # Return worker to pool
+            self._pool.put_nowait(worker)
+
+        # Parse SSE response
+        async for event in self._parse_sse_text(raw_body, private_key):
+            yield event
+
+    async def _parse_sse_text(self, text: str, private_key) -> AsyncIterator[dict]:
+        for line in text.split("\n"):
+            line = line.strip()
+            if not line or line.startswith(":") or line.startswith("event:"):
+                continue
+            if not line.startswith("data: "):
+                continue
+            data = line[6:]
+            if data == "[DONE]":
+                yield {"type": "done"}
+                return
+
+            try:
+                parsed = json.loads(data)
+            except json.JSONDecodeError:
+                dec = _decrypt_data(private_key, data)
+                if dec:
+                    try:
+                        parsed = json.loads(dec)
+                    except json.JSONDecodeError:
+                        yield {"type": "text", "data": dec}
+                        continue
+                else:
+                    continue
+
+            if "encryptedData" in parsed:
+                dec = _decrypt_data(private_key, parsed["encryptedData"])
+                if dec:
+                    try:
+                        inner = json.loads(dec)
+                        yield {"type": "message", "data": inner}
+                    except json.JSONDecodeError:
+                        yield {"type": "text", "data": dec}
+                continue
+
+            action = parsed.get("action")
+            role = parsed.get("role", "")
+
+            # Tool invocation events (WebSearch, etc.)
+            if role == "tool-invocation":
+                state = parsed.get("state", "")
+                if state == "call":
+                    yield {"type": "search_begin", "data": parsed}
+                elif state == "result":
+                    yield {"type": "search_results", "data": parsed}
+                else:
+                    yield {"type": "event", "data": parsed}
+                continue
+
+            # Source/citation events from web search
+            if role == "source":
+                source = parsed.get("source", {})
+                yield {"type": "search_source", "data": source}
+                continue
+
+            if action in ("search_begin", "search_end"):
+                yield {"type": action, "data": parsed}
+            elif action in ("search_result", "search_results"):
+                yield {"type": "search_results", "data": parsed}
+            elif "message" in parsed:
+                msg = parsed["message"]
+                if isinstance(msg, str):
+                    yield {"type": "text", "data": msg}
+                else:
+                    yield {"type": "event", "data": parsed}
+            elif "data" in parsed:
+                val = parsed["data"]
+                if isinstance(val, str):
+                    dec = _decrypt_data(private_key, val)
+                    yield {"type": "text", "data": dec if dec else val}
+                else:
+                    yield {"type": "event", "data": parsed}
+            else:
+                yield {"type": "event", "data": parsed}
+
+    def pool_status(self) -> dict:
+        """Return current pool utilization stats."""
+        if not self._ready:
+            return {"ready": False}
+        total = len(self._workers)
+        available = self._pool.qsize() if self._pool else 0
+        return {
+            "ready": True,
+            "total_workers": total,
+            "available_workers": available,
+            "busy_workers": total - available,
+            "worker_stats": [
+                {"id": w.id, "requests": w.request_count, "ready": w.ready}
+                for w in self._workers
+            ],
+        }
+
+    async def close(self):
+        for w in self._workers:
+            await w.close()
+        self._workers.clear()
+        try:
+            if self._browser:
+                await self._browser.close()
+            if self._playwright:
+                await self._playwright.stop()
+        except:
+            pass
+        self._ready = False

requirements.txt

@@ -0,0 +1,7 @@
+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0
+playwright>=1.40.0
+cryptography>=41.0.0
+# For headless Linux servers (optional, not needed on Windows/macOS):
+# pyvirtualdisplay>=3.0
+# Also install system package: apt-get install xvfb

server.py

@@ -0,0 +1,467 @@
+import json
+import os
+import time
+import uuid
+import logging
+import asyncio
+from typing import Optional
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import StreamingResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+
+from duck_client import DuckAIClient
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+logger = logging.getLogger(__name__)
+
+CONFIG_FILE = os.environ.get("CONFIG_FILE", "config.json")
+
+
+def load_config() -> dict:
+    try:
+        with open(CONFIG_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except FileNotFoundError:
+        return {}
+
+
+config = load_config()
+
+
+def env_or_config(env_name: str, config_key: str, default=None, cast=None):
+    value = os.environ.get(env_name)
+    if value is None:
+        value = config.get(config_key, default)
+    if value is None:
+        return None
+    if cast is bool:
+        if isinstance(value, bool):
+            return value
+        return str(value).strip().lower() in {"1", "true", "yes", "on"}
+    if cast is int:
+        return int(value)
+    if cast:
+        return cast(value)
+    return value
+
+
+API_KEY = env_or_config("API_KEY", "api_key", "sk-duck-ai")
+PROXY = env_or_config("PROXY", "proxy", None)
+HOST = env_or_config("HOST", "host", "0.0.0.0")
+PORT = env_or_config("PORT", "port", 7860, cast=int)
+DEFAULT_MODEL = env_or_config("DEFAULT_MODEL", "default_model", "claude-haiku-4-5")
+ASSISTANT_NAME = env_or_config("ASSISTANT_NAME", "assistant_name", None)
+SYSTEM_PROMPT = env_or_config("SYSTEM_PROMPT", "system_prompt", None)
+WEB_SEARCH = env_or_config("WEB_SEARCH", "web_search", True, cast=bool)
+POOL_SIZE = env_or_config("POOL_SIZE", "pool_size", 2, cast=int)
+
+# Single shared client with page pool
+_shared_client: Optional[DuckAIClient] = None
+_client_lock = asyncio.Lock()
+
+
+async def get_client() -> DuckAIClient:
+    global _shared_client
+    async with _client_lock:
+        if _shared_client is None:
+            _shared_client = DuckAIClient(
+                proxy=PROXY,
+                model=DEFAULT_MODEL,
+                assistant_name=ASSISTANT_NAME,
+                system_prompt=SYSTEM_PROMPT,
+                pool_size=POOL_SIZE,
+            )
+        return _shared_client
+
+
+async def return_client(c: DuckAIClient):
+    return None
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    logger.info("Duck.ai 2API server starting on %s:%s", HOST, PORT)
+    logger.info("Default model: %s", DEFAULT_MODEL)
+    logger.info("Web search: %s", WEB_SEARCH)
+    logger.info("Pool size: %s", POOL_SIZE)
+    logger.info("Proxy: %s", PROXY or "None")
+    yield
+    global _shared_client
+    if _shared_client:
+        await _shared_client.close()
+        _shared_client = None
+    logger.info("Server shutdown complete")
+
+
+app = FastAPI(title="Duck.ai 2API", lifespan=lifespan)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+def verify_auth(request: Request):
+    if not API_KEY:
+        return
+    auth = request.headers.get("Authorization", "")
+    if auth.startswith("Bearer "):
+        token = auth[7:]
+    else:
+        token = auth
+    if token != API_KEY:
+        raise HTTPException(status_code=401, detail="Invalid API key")
+
+
+MODEL_MAP = {
+    "claude-haiku-4-5": "claude-haiku-4-5",
+    "claude-3-haiku": "claude-haiku-4-5",
+    "claude-3-5-haiku": "claude-haiku-4-5",
+    "claude-3-haiku-20240307": "claude-haiku-4-5",
+    "gpt-4o-mini": "gpt-4o-mini",
+    "gpt-4o": "gpt-4o-mini",
+    "gpt-3.5-turbo": "gpt-4o-mini",
+    "llama-3.3-70b": "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+    "mixtral-8x7b": "mistralai/Mixtral-8x7B-Instruct-v0.1",
+    "o3-mini": "o3-mini",
+}
+
+
+def map_model(model: str) -> str:
+    return MODEL_MAP.get(model, DEFAULT_MODEL)
+
+
+@app.get("/v1/models")
+@app.get("/models")
+async def list_models(request: Request):
+    verify_auth(request)
+    models = [
+        {"id": "claude-haiku-4-5", "object": "model", "owned_by": "anthropic"},
+        {"id": "gpt-4o-mini", "object": "model", "owned_by": "openai"},
+        {"id": "o3-mini", "object": "model", "owned_by": "openai"},
+        {"id": "meta-llama/Llama-3.3-70B-Instruct-Turbo", "object": "model", "owned_by": "meta"},
+        {"id": "mistralai/Mixtral-8x7B-Instruct-v0.1", "object": "model", "owned_by": "mistral"},
+    ]
+    return {"object": "list", "data": models}
+
+
+@app.post("/v1/chat/completions")
+@app.post("/chat/completions")
+async def chat_completions(request: Request):
+    verify_auth(request)
+
+    try:
+        body = await request.json()
+    except Exception:
+        raise HTTPException(status_code=400, detail="Invalid JSON body")
+
+    messages = body.get("messages", [])
+    if not messages:
+        raise HTTPException(status_code=400, detail="messages is required")
+
+    req_model = body.get("model", DEFAULT_MODEL)
+    duck_model = map_model(req_model)
+    stream = body.get("stream", False)
+    web_search = body.get("web_search", WEB_SEARCH)
+
+    custom_instructions = None
+    assistant_name = ASSISTANT_NAME
+    for msg in messages:
+        if msg.get("role") == "system":
+            custom_instructions = msg.get("content", "")
+            break
+
+    completion_id = f"chatcmpl-{uuid.uuid4().hex[:24]}"
+    created = int(time.time())
+
+    client = await get_client()
+    client.model = duck_model
+
+    if stream:
+        return StreamingResponse(
+            _stream_response(
+                client,
+                messages,
+                web_search,
+                custom_instructions,
+                assistant_name,
+                completion_id,
+                created,
+                req_model,
+            ),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "X-Accel-Buffering": "no",
+            },
+        )
+    return await _non_stream_response(
+        client,
+        messages,
+        web_search,
+        custom_instructions,
+        assistant_name,
+        completion_id,
+        created,
+        req_model,
+    )
+
+
+async def _stream_response(client: DuckAIClient, messages: list,
+                           web_search: bool, custom_instructions: str,
+                           assistant_name: str, completion_id: str,
+                           created: int, model: str):
+    try:
+        first_chunk = {
+            "id": completion_id,
+            "object": "chat.completion.chunk",
+            "created": created,
+            "model": model,
+            "choices": [{
+                "index": 0,
+                "delta": {"role": "assistant", "content": ""},
+                "finish_reason": None,
+            }],
+        }
+        yield f"data: {json.dumps(first_chunk)}\n\n"
+
+        search_sources = []
+        async for event in client.chat_stream(
+            messages=messages,
+            web_search=web_search,
+            custom_instructions=custom_instructions,
+            assistant_name=assistant_name,
+        ):
+            etype = event.get("type")
+
+            if etype == "text":
+                text = event.get("data", "")
+                if text and isinstance(text, str):
+                    chunk = {
+                        "id": completion_id,
+                        "object": "chat.completion.chunk",
+                        "created": created,
+                        "model": model,
+                        "choices": [{
+                            "index": 0,
+                            "delta": {"content": text},
+                            "finish_reason": None,
+                        }],
+                    }
+                    yield f"data: {json.dumps(chunk)}\n\n"
+            elif etype == "message":
+                data = event.get("data", {})
+                text = ""
+                if isinstance(data, dict):
+                    text = data.get("message", data.get("content", ""))
+                elif isinstance(data, str):
+                    text = data
+                if text and isinstance(text, str):
+                    chunk = {
+                        "id": completion_id,
+                        "object": "chat.completion.chunk",
+                        "created": created,
+                        "model": model,
+                        "choices": [{
+                            "index": 0,
+                            "delta": {"content": text},
+                            "finish_reason": None,
+                        }],
+                    }
+                    yield f"data: {json.dumps(chunk)}\n\n"
+            elif etype == "search_source":
+                src = event.get("data", {})
+                if isinstance(src, dict) and src.get("url"):
+                    search_sources.append(src)
+            elif etype in ("search_begin", "search_results", "search_end"):
+                pass
+            elif etype == "done":
+                break
+            elif etype == "event":
+                data = event.get("data", {})
+                if isinstance(data, dict):
+                    msg = data.get("message", data.get("content", ""))
+                    if msg and isinstance(msg, str):
+                        chunk = {
+                            "id": completion_id,
+                            "object": "chat.completion.chunk",
+                            "created": created,
+                            "model": model,
+                            "choices": [{
+                                "index": 0,
+                                "delta": {"content": msg},
+                                "finish_reason": None,
+                            }],
+                        }
+                        yield f"data: {json.dumps(chunk)}\n\n"
+
+        if search_sources:
+            refs = "\n\n---\n**搜索结果:**\n"
+            for i, src in enumerate(search_sources[:8], 1):
+                title = src.get("title", "")
+                url = src.get("url", "")
+                site = src.get("site", "")
+                favicon = f"https://www.google.com/s2/favicons?domain={site}&sz=32" if site else ""
+                if title and url:
+                    icon = f"![favicon]({favicon}) " if favicon else ""
+                    refs += f"{i}. {icon}[{title}]({url}) - {site}\n"
+            chunk = {
+                "id": completion_id,
+                "object": "chat.completion.chunk",
+                "created": created,
+                "model": model,
+                "choices": [{
+                    "index": 0,
+                    "delta": {"content": refs},
+                    "finish_reason": None,
+                }],
+            }
+            yield f"data: {json.dumps(chunk)}\n\n"
+
+        final_chunk = {
+            "id": completion_id,
+            "object": "chat.completion.chunk",
+            "created": created,
+            "model": model,
+            "choices": [{
+                "index": 0,
+                "delta": {},
+                "finish_reason": "stop",
+            }],
+        }
+        yield f"data: {json.dumps(final_chunk)}\n\n"
+        yield "data: [DONE]\n\n"
+    except Exception as e:
+        logger.error("Stream error: %s", e, exc_info=True)
+        error_chunk = {
+            "id": completion_id,
+            "object": "chat.completion.chunk",
+            "created": created,
+            "model": model,
+            "choices": [{
+                "index": 0,
+                "delta": {"content": f"\n\n[Error: {str(e)}]"},
+                "finish_reason": "stop",
+            }],
+        }
+        yield f"data: {json.dumps(error_chunk)}\n\n"
+        yield "data: [DONE]\n\n"
+    finally:
+        await return_client(client)
+
+
+async def _non_stream_response(client: DuckAIClient, messages: list,
+                               web_search: bool, custom_instructions: str,
+                               assistant_name: str, completion_id: str,
+                               created: int, model: str):
+    full_content = ""
+    search_sources = []
+    try:
+        async for event in client.chat_stream(
+            messages=messages,
+            web_search=web_search,
+            custom_instructions=custom_instructions,
+            assistant_name=assistant_name,
+        ):
+            etype = event.get("type")
+            if etype == "text":
+                val = event.get("data", "")
+                if isinstance(val, str):
+                    full_content += val
+            elif etype == "message":
+                data = event.get("data", {})
+                if isinstance(data, dict):
+                    msg = data.get("message", data.get("content", ""))
+                    if isinstance(msg, str):
+                        full_content += msg
+                elif isinstance(data, str):
+                    full_content += data
+            elif etype == "search_source":
+                src = event.get("data", {})
+                if isinstance(src, dict) and src.get("url"):
+                    search_sources.append(src)
+            elif etype == "event":
+                data = event.get("data", {})
+                if isinstance(data, dict):
+                    msg = data.get("message", data.get("content", ""))
+                    if isinstance(msg, str):
+                        full_content += msg
+            elif etype == "done":
+                break
+    except Exception as e:
+        logger.error("Chat error: %s", e, exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        await return_client(client)
+
+    if search_sources:
+        refs = "\n\n---\n**搜索结果:**\n"
+        for i, src in enumerate(search_sources[:8], 1):
+            title = src.get("title", "")
+            url = src.get("url", "")
+            site = src.get("site", "")
+            favicon = f"https://www.google.com/s2/favicons?domain={site}&sz=32" if site else ""
+            if title and url:
+                icon = f"![favicon]({favicon}) " if favicon else ""
+                refs += f"{i}. {icon}[{title}]({url}) - {site}\n"
+        full_content += refs
+
+    prompt_tokens = sum(len(m.get("content", "")) for m in messages) // 4
+    completion_tokens = len(full_content) // 4
+
+    return JSONResponse({
+        "id": completion_id,
+        "object": "chat.completion",
+        "created": created,
+        "model": model,
+        "choices": [{
+            "index": 0,
+            "message": {"role": "assistant", "content": full_content},
+            "finish_reason": "stop",
+        }],
+        "usage": {
+            "prompt_tokens": prompt_tokens,
+            "completion_tokens": completion_tokens,
+            "total_tokens": prompt_tokens + completion_tokens,
+        },
+    })
+
+
+@app.get("/")
+async def root():
+    return {
+        "service": "Duck.ai 2API",
+        "status": "running",
+        "model": DEFAULT_MODEL,
+        "docs": "/docs",
+        "health": "/health",
+    }
+
+
+@app.get("/health")
+async def health():
+    client = None
+    try:
+        client = await get_client()
+        return {
+            "status": "ok",
+            "model": DEFAULT_MODEL,
+            "pool": client.pool_status(),
+        }
+    except Exception as e:
+        return JSONResponse(
+            status_code=503,
+            content={"status": "error", "detail": str(e)},
+        )
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run("server:app", host=HOST, port=PORT, reload=False)