Update main.py

main.py

@@ -13,25 +13,21 @@ from fastapi.responses import JSONResponse
 # ====================================================================
 API_SECRET_KEY = os.getenv("API_SECRET_KEY", "change-me-secret")
 
+# key = ما يرسله المستخدم في "model"
+# value = النص الذي يظهر في زر model-select-button في duck.ai
 DUCK_MODELS = {
-    "gpt-4o-mini":      "gpt-4o-mini",
-    "gpt-5-mini":       "gpt-5-mini",
-    "o3-mini":          "o3-mini",
-    "gpt-oss-120b":     "gpt-oss-120b",
-    "claude-haiku-4-5": "claude-haiku-4-5",
-    "claude-3-haiku":   "claude-3-haiku-20240307",
-    "llama-4-scout":    "meta-llama/Llama-4-Scout-17B-16E-Instruct",
-    "llama-3.3-70b":    "meta-llama/Llama-3.3-70B-Instruct-Turbo",
-    "mistral-small-4":  "mistralai/Mistral-Small-3.1-24B-Instruct-2503",
-    "mistral-small":    "mistralai/Mistral-Small-24B-Instruct-2501",
+    "gpt-5-mini":       "GPT-5 mini",
+    "gpt-5":            "GPT-5",
+    "gpt-4o-mini":      "GPT-4o mini",
+    "o3-mini":          "o3 mini",
+    "gpt-oss-120b":     "gpt-oss 120B",
+    "claude-haiku-4-5": "Claude Haiku 4.5",
+    "llama-4-scout":    "Llama 4 Scout",
+    "mistral-small-4":  "Mistral Small 4",
 }
 
-ZAI_MODELS = [
-    "GLM-5.1", "GLM-5-Turbo", "GLM-5V-Turbo",
-    "GLM-5", "GLM-4.7", "GLM-4.6V", "GLM-4.5-Air"
-]
-
-ALL_MODELS = list(DUCK_MODELS.keys()) + ZAI_MODELS
+ALL_MODELS = list(DUCK_MODELS.keys())
+DEFAULT_MODEL = "gpt-5-mini"
 
 # ====================================================================
 # Browser Engine
@@ -49,12 +45,12 @@ class AsyncBrowserThread(threading.Thread):
         asyncio.set_event_loop(self.loop)
         self.loop.run_until_complete(self._start_browser())
         self.ready_event.set()
-        print("[SERVER] Browser is ready!")
+        print("[DUCK] Browser ready!")
         self.loop.run_forever()
 
     async def _start_browser(self):
         from playwright.async_api import async_playwright
-        print("[SERVER] Starting Chrome...")
+        print("[DUCK] Launching Chrome...")
         self.playwright = await async_playwright().start()
         self.browser = await self.playwright.chromium.launch(
             headless=True,
@@ -69,12 +65,13 @@ class AsyncBrowserThread(threading.Thread):
                 "--no-zygote",
             ],
         )
-        print("[SERVER] Chrome launched!")
+        print("[DUCK] Chrome launched!")
 
-    # ────────────────────────────────────────────────────────────────
-    # Duck.ai
-    # ────────────────────────────────────────────────────────────────
-    async def _talk_to_duck(self, model_id: str, messages: list) -> str:
+    async def _chat(self, model_label: str, prompt: str) -> str:
+        """
+        model_label: النص الظاهر في واجهة duck.ai مثل 'GPT-5 mini'
+        prompt: النص الكامل للإرسال
+        """
         context = await self.browser.new_context(
             user_agent=(
                 "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
@@ -87,207 +84,178 @@ class AsyncBrowserThread(threading.Thread):
             "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
         )
         page = await context.new_page()
+
         try:
             page.set_default_timeout(120000)
-            prompt = _build_duck_prompt(messages)
 
-            # ── 1. فتح الصفحة ──────────────────────────────────────
+            # ── 1. فتح duck.ai ──────────────────────────────────────
             await page.goto("https://duckduckgo.com/aichat", wait_until="domcontentloaded")
             await asyncio.sleep(5)
 
-            # ── 2. قبول الشروط إن ظهرت ────────────────────────────
+            # ── 2. إغلاق أي banner/notification ────────────────────
+            # إغلاق إشعار PDF إن ظهر
             try:
-                btns = ["button:has-text('Got it')",
-                        "button:has-text('Accept')",
-                        "button:has-text('Get started')",
-                        "button:has-text('I agree')",
-                        "[data-testid='accept-terms']"]
-                for btn_sel in btns:
-                    btn = page.locator(btn_sel)
-                    if await btn.count() > 0:
-                        await btn.first.click()
-                        await asyncio.sleep(2)
-                        break
+                close_btns = page.locator("button[aria-label='Close'], button.XkSxBJ8ofSQsZmGZs6qx")
+                if await close_btns.count() > 0:
+                    await close_btns.first.click()
+                    await asyncio.sleep(1)
             except Exception:
                 pass
 
-            # ── 3. الانتظار حتى يظهر صندوق الكتابة ────────────────
-            # الـ selector المثبت من مصادر حقيقية
-            await page.wait_for_selector("textarea[name='user-prompt']", timeout=30000)
+            # ── 3. انتظار صندوق الكتابة (الـ selector الحقيقي) ─────
+            # من HTML: <textarea name="user-prompt" ...>
+            await page.wait_for_selector('textarea[name="user-prompt"]', timeout=30000)
+            print("[DUCK] Chat input found ✓")
 
-            # ── 4. إرسال الرسالة ───────────────────────────────────
-            textarea = page.locator("textarea[name='user-prompt']")
+            # ── 4. تغيير النموذج إذا كان مختلفاً ───────────────────
+            # من HTML: <button data-testid="model-select-button"><span>GPT-5</span>
+            try:
+                model_btn = page.locator('button[data-testid="model-select-button"]')
+                current_model_text = await model_btn.inner_text()
+                print(f"[DUCK] Current model: {current_model_text.strip()}")
+
+                # تحقق إن كان النموذج مختلف
+                if model_label.lower() not in current_model_text.lower():
+                    await model_btn.click()
+                    await asyncio.sleep(1.5)
+
+                    # البحث عن النموذج المطلوب في القائمة
+                    option = page.locator(f"li:has-text('{model_label}'), button:has-text('{model_label}'), [role='option']:has-text('{model_label}')")
+                    if await option.count() > 0:
+                        await option.first.click()
+                        await asyncio.sleep(1)
+                        print(f"[DUCK] Model changed to: {model_label} ✓")
+                    else:
+                        # أغلق القائمة
+                        await page.keyboard.press("Escape")
+                        print(f"[DUCK] Model '{model_label}' not found in list, using default")
+            except Exception as e:
+                print(f"[DUCK] Model selection error (non-fatal): {e}")
+
+            # ── 5. كتابة الرسالة وإرسالها ──────────────────────────
+            textarea = page.locator('textarea[name="user-prompt"]')
             await textarea.click()
             await textarea.fill(prompt)
             await asyncio.sleep(0.5)
 
-            # إيجاد زر الإرسال والضغط عليه
-            send_btn = page.locator("button[type='submit'], button[aria-label*='Send'], button[aria-label*='send']")
-            if await send_btn.count() > 0:
-                await send_btn.first.click()
-            else:
-                await page.keyboard.press("Enter")
-
-            print(f"[DUCK] Sent prompt ({len(prompt)} chars)")
+            # من HTML: <button type="submit" aria-label="Send" ...>
+            # زر الإرسال يكون disabled=true حتى يوجد نص، بعد fill يصبح enabled
+            send_btn = page.locator('button[type="submit"][aria-label="Send"]')
+            await send_btn.wait_for(state="enabled", timeout=10000)
+            await send_btn.click()
+            print(f"[DUCK] Message sent ({len(prompt)} chars) ✓")
 
-            # ── 5. انتظار بدء الرد ────────────────────────────────
+            # ── 6. انتظار بدء الرد ────────────────────────────────
             await asyncio.sleep(3)
 
-            # انتظر وقف المؤشر الوامض (يعني انتهى الرد)
-            # duck.ai يضيف data-copyairesponse على زر النسخ عند اكتمال الرد
+            # انتظر ظهور زر "Stop generating" (يعني الرد بدأ)
+            # من HTML: <button aria-label="Stop generating" ...>
             try:
-                await page.wait_for_selector(
-                    "button[data-copyairesponse='true']",
-                    timeout=90000
-                )
-                await asyncio.sleep(1)
+                stop_btn = page.locator('button[aria-label="Stop generating"]')
+                await stop_btn.wait_for(state="visible", timeout=20000)
+                print("[DUCK] Response started ✓")
             except Exception:
-                # fallback: انتظر ثابت
-                await asyncio.sleep(15)
-
-            # ── 6. استخراج النص ───────────────────────────────────
+                print("[DUCK] Stop button not detected, waiting...")
+
+            # ── 7. انتظار اكتمال الرد ─────────────────────────────
+            # الرد اكتمل عندما يختفي "Stop generating" ويظهر "Send" مرة أخرى
+            max_wait = 120  # ثانية
+            elapsed  = 0
+            while elapsed < max_wait:
+                await asyncio.sleep(2)
+                elapsed += 2
+                # تحقق هل Stop button اختفى (= الرد انتهى)
+                stop_visible = await page.locator('button[aria-label="Stop generating"]:not([disabled])').count()
+                if stop_visible == 0:
+                    print(f"[DUCK] Response complete after ~{elapsed}s ✓")
+                    break
+
+            await asyncio.sleep(1.5)  # انتظار إضافي للتأكد من اكتمال الرسم
+
+            # ── 8. استخراج الرد ───────────────────────────────────
             response_text = await page.evaluate("""
                 () => {
-                    // duck.ai يضع الردود في عناصر بجانب زر النسخ
-                    // نجيب آخر رد في الصفحة
-                    const copyBtns = document.querySelectorAll("button[data-copyairesponse='true']");
-                    if (copyBtns.length > 0) {
-                        const lastCopyBtn = copyBtns[copyBtns.length - 1];
-                        // الرد في الـ parent container قبل زر النسخ
-                        const msgContainer = lastCopyBtn.closest('[class*="message"], [class*="Message"], [class*="response"], [class*="Response"]');
-                        if (msgContainer) return msgContainer.innerText.trim();
+                    // duck.ai يضع ردود الـ AI في عناصر article أو divs خاصة
+                    // نبحث عن آخر رد في الصفحة
+
+                    // طريقة 1: article elements (الطريقة الأكثر موثوقية)
+                    const articles = document.querySelectorAll('article');
+                    if (articles.length > 0) {
+                        return articles[articles.length - 1].innerText.trim();
                     }
 
-                    // fallback: كل العناصر التي تبدو كردود AI
-                    const allArticles = document.querySelectorAll('article, [role="article"]');
-                    if (allArticles.length > 0) {
-                        const last = allArticles[allArticles.length - 1];
-                        return last.innerText.trim();
+                    // طريقة 2: divs مع role="presentation" أو class تحتوي على message
+                    const msgDivs = document.querySelectorAll(
+                        '[class*="message"]:not([class*="user"]):not([class*="User"]):not([class*="input"])'
+                    );
+                    if (msgDivs.length > 0) {
+                        // فلتر العناصر التي تحتوي على نص حقيقي
+                        const textDivs = [...msgDivs].filter(el =>
+                            el.innerText && el.innerText.trim().length > 20 &&
+                            !el.querySelector('textarea')
+                        );
+                        if (textDivs.length > 0) {
+                            return textDivs[textDivs.length - 1].innerText.trim();
+                        }
                     }
 
-                    // آخر حل: أخذ كل النصوص الطويلة
-                    const divs = [...document.querySelectorAll('div')].filter(d =>
-                        d.children.length < 5 &&
-                        d.innerText &&
-                        d.innerText.trim().length > 100
+                    // طريقة 3: البحث عن أطول div بالصفحة لا يحتوي على textarea
+                    const allDivs = [...document.querySelectorAll('div')].filter(el =>
+                        el.children.length < 10 &&
+                        el.innerText &&
+                        el.innerText.trim().length > 50 &&
+                        !el.querySelector('textarea') &&
+                        !el.querySelector('button[type="submit"]')
                     );
-                    if (divs.length > 0) return divs[divs.length - 1].innerText.trim();
+                    if (allDivs.length > 0) {
+                        // أخذ آخر div بنص طويل
+                        const sorted = allDivs.sort((a, b) => b.innerText.length - a.innerText.length);
+                        return sorted[0].innerText.trim();
+                    }
+
                     return '';
                 }
             """)
 
-            # إذا كان النص فارغاً، انتظر أكثر وحاول مرة ثانية
-            if not response_text or len(response_text.strip()) < 5:
-                await asyncio.sleep(8)
+            # إذا فارغ، انتظر أكثر وحاول مرة ثانية
+            if not response_text or len(response_text.strip()) < 10:
+                await asyncio.sleep(5)
                 response_text = await page.evaluate("""
                     () => {
-                        const copyBtns = document.querySelectorAll("button[data-copyairesponse='true']");
-                        if (copyBtns.length > 0) {
-                            const last = copyBtns[copyBtns.length - 1];
-                            let el = last.parentElement;
-                            for (let i = 0; i < 5; i++) {
-                                if (el && el.innerText && el.innerText.trim().length > 30) {
-                                    return el.innerText.trim();
-                                }
-                                el = el ? el.parentElement : null;
-                            }
+                        const articles = document.querySelectorAll('article');
+                        if (articles.length > 0) {
+                            return articles[articles.length - 1].innerText.trim();
                         }
-                        return document.body.innerText.slice(0, 3000);
+                        // آخر حل: نص الصفحة كامل وقص المناطق المعروفة
+                        return document.body.innerText.slice(0, 5000);
                     }
                 """)
 
-            print(f"[DUCK] Response: {len(response_text)} chars")
+            print(f"[DUCK] Extracted {len(response_text)} chars ✓")
             return response_text.strip()
 
         except Exception as e:
             print(f"[DUCK] Error: {e}")
-            raise e
-        finally:
-            await page.close()
-            await context.close()
-
-    # ────────────────────────────────────────────────────────────────
-    # ZAI (محفوظ كما هو بالكامل)
-    # ────────────────────────────────────────────────────────────────
-    async def _talk_to_zai(self, prompt: str) -> str:
-        context = await self.browser.new_context(
-            user_agent=(
-                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
-                "AppleWebKit/537.36 (KHTML, like Gecko) "
-                "Chrome/124.0.0.0 Safari/537.36"
-            ),
-            viewport={"width": 1920, "height": 1080},
-        )
-        await context.add_init_script(
-            "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
-        )
-        page = await context.new_page()
-        try:
-            page.set_default_timeout(120000)
-            await page.goto("https://chat.z.ai/", wait_until="domcontentloaded")
-            await asyncio.sleep(3)
-            await page.wait_for_selector("textarea#chat-input", timeout=60000)
-            await page.fill("textarea#chat-input", prompt)
-            await asyncio.sleep(0.5)
-            await page.press("textarea#chat-input", "Enter")
-            print(f"[ZAI] Sent ({len(prompt)} chars)")
-            await asyncio.sleep(2)
-            await page.wait_for_selector("#response-content-container", timeout=120000)
-            last_text     = ""
-            unchanged_cnt = 0
-            while unchanged_cnt < 5:
-                current_text = await page.evaluate("""
-                    () => {
-                        const prose = document.querySelector(
-                            '#response-content-container .markdown-prose'
-                        );
-                        if (!prose) return '';
-                        const clone = prose.cloneNode(true);
-                        clone.querySelectorAll(':scope > div').forEach(el => el.remove());
-                        return clone.innerText.trim();
-                    }
-                """)
-                if current_text == last_text and current_text.strip():
-                    unchanged_cnt += 1
-                else:
-                    last_text     = current_text
-                    unchanged_cnt = 0
-                await asyncio.sleep(1.0)
-            print(f"[ZAI] Response: {len(last_text)} chars")
-            return last_text.strip()
-        except Exception as e:
-            print(f"[ZAI] Error: {e}")
-            raise e
+            raise RuntimeError(f"duck.ai error: {e}")
         finally:
             await page.close()
             await context.close()
 
-    # ────────────────────────────────────────────────────────────────
-    # Public blocking methods
-    # ────────────────────────────────────────────────────────────────
-    def _wait_ready(self):
-        if not self.ready_event.wait(timeout=60):
-            raise Exception("Browser not ready after 60s")
-
-    def process_duck(self, model_id: str, messages: list) -> str:
-        self._wait_ready()
+    def process(self, model_label: str, prompt: str) -> str:
+        if not self.ready_event.wait(timeout=90):
+            raise RuntimeError("Browser not ready after 90s")
         future = asyncio.run_coroutine_threadsafe(
-            self._talk_to_duck(model_id, messages), self.loop
+            self._chat(model_label, prompt), self.loop
         )
         return future.result(timeout=180)
 
-    def process_zai(self, prompt: str) -> str:
-        self._wait_ready()
-        future = asyncio.run_coroutine_threadsafe(self._talk_to_zai(prompt), self.loop)
-        return future.result(timeout=120)
-
 
 browser_engine = AsyncBrowserThread()
 browser_engine.start()
 
 
 # ====================================================================
-# Prompt Helpers
+# Helpers
 # ====================================================================
 
 def _extract_content(msg: dict) -> str:
@@ -303,7 +271,11 @@ def _extract_content(msg: dict) -> str:
     return str(content) if content else ""
 
 
-def _build_duck_prompt(messages: list) -> str:
+def _build_prompt(messages: list) -> str:
+    """
+    يبني prompt نصي واضح من قائمة messages
+    يدمج system prompt + التاريخ + السؤال الأخير
+    """
     parts = []
     for msg in messages:
         role    = msg.get("role", "user")
@@ -311,92 +283,16 @@ def _build_duck_prompt(messages: list) -> str:
         if not content.strip():
             continue
         if role == "system":
-            parts.append(f"[INSTRUCTIONS]:\n{content}")
+            parts.append(f"=== SYSTEM INSTRUCTIONS ===\n{content}\n=== END INSTRUCTIONS ===")
         elif role == "assistant":
-            parts.append(f"[Previous AI response]:\n{content}")
+            parts.append(f"[Assistant]: {content}")
         else:
             parts.append(content)
-    if len(parts) > 1:
-        return "\n\n---\n\n".join(parts)
     return "\n\n".join(parts)
 
 
-def format_prompt(messages, tools=None):
-    parts            = []
-    system_parts     = []
-    has_tool_results = False
-    user_question    = ""
-
-    for msg in messages:
-        role     = msg.get("role", "")
-        msg_type = msg.get("type", "")
-        content  = _extract_content(msg)
-
-        if role == "system":
-            system_parts.append(content)
-        elif role == "tool":
-            has_tool_results = True
-            parts.append(f"[TOOL RESULT from '{msg.get('name','tool')}']:\n{content}")
-        elif msg_type == "function_call_output":
-            has_tool_results = True
-            parts.append(f"[TOOL RESULT (call_id: {msg.get('call_id','')})]:\n{msg.get('output', content)}")
-        elif msg_type == "function_call":
-            parts.append(f"[PREVIOUS TOOL CALL: Called '{msg.get('name','?')}' with arguments: {msg.get('arguments','{}')}]")
-        elif role == "assistant":
-            ac = content
-            tc_list = msg.get("tool_calls", [])
-            if tc_list:
-                td = [f"Called '{t.get('function',{}).get('name','?')}' with: {t.get('function',{}).get('arguments','{}')}" for t in tc_list]
-                ac += "\n[Previous tool calls: " + "; ".join(td) + "]"
-            if ac.strip():
-                parts.append(f"[Assistant]: {ac}")
-        elif role == "user" or (msg_type == "message" and role != "system"):
-            user_question    = content
-            has_tool_results = False
-            parts.append(content)
-        elif content:
-            parts.append(content)
-
-    final = ""
-    if system_parts:
-        if tools and not has_tool_results:
-            final += "=== YOUR ROLE ===\n" + "\n\n".join(system_parts) + "\n=== END OF ROLE ===\n\n"
-        else:
-            final += "=== SYSTEM INSTRUCTIONS (FOLLOW STRICTLY) ===\n" + "\n\n".join(system_parts) + "\n=== END OF INSTRUCTIONS ===\n\n"
-    if tools and not has_tool_results:
-        final += _format_tools_instruction(tools, user_question)
-    if has_tool_results:
-        final += "=== CONTEXT FROM TOOLS ===\nUse ONLY this information to answer.\n\n"
-    if parts:
-        final += "\n".join(parts)
-    if has_tool_results:
-        final += "\n\n=== INSTRUCTION ===\nAnswer based ONLY on tool results above.\n"
-    return final
-
-
-def _format_tools_instruction(tools, user_question=""):
-    i  = "\n=== MANDATORY TOOL USAGE ===\n"
-    i += "You MUST use one of the tools below. Respond with ONLY valid JSON.\n\n"
-    i += 'FORMAT: {"tool_calls": [{"name": "TOOL_NAME", "arguments": {"param": "value"}}]}\n\n'
-    i += "Available tools:\n\n"
-    for tool in tools:
-        func = tool.get("function", tool)
-        i += f"Tool: {func.get('name','unknown')}\nDescription: {func.get('description','')}\n"
-        params = func.get("parameters", {})
-        if params.get("properties"):
-            i += "Parameters:\n"
-            req = params.get("required", [])
-            for pn, pi in params["properties"].items():
-                i += f"  - {pn} ({pi.get('type','string')}, {'required' if pn in req else 'optional'}): {pi.get('description','')}\n"
-        i += "\n"
-    i += "=== END OF TOOLS ===\n\n"
-    fn = (tools[0] if tools else {}).get("function", tools[0] if tools else {}).get("name", "tool")
-    i += f'Now respond with JSON to call the tool:\n'
-    return i
-
-
-def parse_tool_calls(response_text):
-    cleaned = response_text.strip()
+def _parse_tool_calls(text: str):
+    cleaned = text.strip()
     if "```" in cleaned:
         m = re.search(r'```(?:json)?\s*\n?(.*?)\n?\s*```', cleaned, re.DOTALL)
         if m:
@@ -416,45 +312,50 @@ def parse_tool_calls(response_text):
                         "type": "function",
                         "function": {
                             "name": call.get("name", ""),
-                            "arguments": json.dumps(call.get("arguments", {}), ensure_ascii=False)
-                                         if isinstance(call.get("arguments"), dict)
-                                         else str(call.get("arguments", "{}"))
-                        }
+                            "arguments": (
+                                json.dumps(call.get("arguments", {}), ensure_ascii=False)
+                                if isinstance(call.get("arguments"), dict)
+                                else str(call.get("arguments", "{}"))
+                            ),
+                        },
                     } for call in raw]
         except (json.JSONDecodeError, TypeError, KeyError):
             continue
     return None
 
 
-# ====================================================================
-# Auth & Shared response builder
-# ====================================================================
-
 def _auth(request: Request) -> bool:
-    return request.headers.get("authorization", "").replace("Bearer ", "").strip() == API_SECRET_KEY
+    token = request.headers.get("authorization", "").replace("Bearer ", "").strip()
+    return token == API_SECRET_KEY
 
 
-def _is_duck(model: str) -> bool:
-    return model in DUCK_MODELS
+def _get_model_label(model: str) -> str:
+    return DUCK_MODELS.get(model, DUCK_MODELS[DEFAULT_MODEL])
 
 
-def _completion_response(start_time, model, text, messages, tools):
-    p = sum(len(_extract_content(m).split()) for m in messages)
-    c = len(text.split())
-    tc = parse_tool_calls(text) if tools else None
+def _make_completion(start_time, model, text, messages, tools=None):
+    p  = sum(len(_extract_content(m).split()) for m in messages)
+    c  = len(text.split())
+    tc = _parse_tool_calls(text) if tools else None
     if tc:
         return {
-            "id": f"chatcmpl-{uuid.uuid4().hex[:29]}", "object": "chat.completion",
-            "created": int(start_time), "model": model,
-            "choices": [{"index": 0, "message": {"role": "assistant", "content": None,
-                         "tool_calls": tc}, "finish_reason": "tool_calls"}],
+            "id":      f"chatcmpl-{uuid.uuid4().hex[:29]}",
+            "object":  "chat.completion",
+            "created": int(start_time),
+            "model":   model,
+            "choices": [{"index": 0, "message": {
+                "role": "assistant", "content": None, "tool_calls": tc
+            }, "finish_reason": "tool_calls"}],
             "usage": {"prompt_tokens": p, "completion_tokens": c, "total_tokens": p + c},
         }
     return {
-        "id": f"chatcmpl-{uuid.uuid4().hex[:29]}", "object": "chat.completion",
-        "created": int(start_time), "model": model,
-        "choices": [{"index": 0, "message": {"role": "assistant", "content": text},
-                     "finish_reason": "stop"}],
+        "id":      f"chatcmpl-{uuid.uuid4().hex[:29]}",
+        "object":  "chat.completion",
+        "created": int(start_time),
+        "model":   model,
+        "choices": [{"index": 0, "message": {
+            "role": "assistant", "content": text
+        }, "finish_reason": "stop"}],
         "usage": {"prompt_tokens": p, "completion_tokens": c, "total_tokens": p + c},
     }
 
@@ -462,7 +363,7 @@ def _completion_response(start_time, model, text, messages, tools):
 # ====================================================================
 # FastAPI
 # ====================================================================
-app = FastAPI(title="ZAI + DuckAI API Server")
+app = FastAPI(title="Duck.ai API Server")
 
 
 @app.post("/v1/chat/completions")
@@ -471,6 +372,7 @@ async def chat_completions(request: Request):
         data = await request.json()
     except Exception:
         return JSONResponse(status_code=400, content={"error": {"message": "Invalid JSON"}})
+
     if not _auth(request):
         return JSONResponse(status_code=401, content={"error": {"message": "Invalid API Key"}})
 
@@ -478,26 +380,21 @@ async def chat_completions(request: Request):
     if not messages:
         return JSONResponse(status_code=400, content={"error": {"message": "messages required"}})
 
-    model      = data.get("model", "gpt-4o-mini")
-    tools      = data.get("tools", None)
-    start_time = time.time()
+    model       = data.get("model", DEFAULT_MODEL)
+    tools       = data.get("tools", None)
+    start_time  = time.time()
+    model_label = _get_model_label(model)
+    prompt      = _build_prompt(messages)
+
+    print(f"[API] /v1/chat/completions → model={model} ({model_label})")
 
     try:
-        if _is_duck(model):
-            model_id = DUCK_MODELS[model]
-            print(f"[SERVER] duck.ai → {model_id}")
-            text = await asyncio.get_event_loop().run_in_executor(
-                None, browser_engine.process_duck, model_id, messages
-            )
-        else:
-            prompt = format_prompt(messages, tools=tools)
-            print(f"[SERVER] zai → {len(prompt)} chars")
-            text = await asyncio.get_event_loop().run_in_executor(
-                None, browser_engine.process_zai, prompt
-            )
-        return _completion_response(start_time, model, text, messages, tools)
+        text = await asyncio.get_event_loop().run_in_executor(
+            None, browser_engine.process, model_label, prompt
+        )
+        return _make_completion(start_time, model, text, messages, tools)
     except Exception as e:
-        print(f"[SERVER] ERROR: {e}")
+        print(f"[API] ERROR: {e}")
         return JSONResponse(status_code=500, content={"error": {"message": str(e)}})
 
 
@@ -507,6 +404,7 @@ async def responses(request: Request):
         data = await request.json()
     except Exception:
         return JSONResponse(status_code=400, content={"error": {"message": "Invalid JSON"}})
+
     if not _auth(request):
         return JSONResponse(status_code=401, content={"error": {"message": "Invalid API Key"}})
 
@@ -517,39 +415,44 @@ async def responses(request: Request):
         messages = input_data
     else:
         messages = data.get("messages", [])
+
     if not messages:
         return JSONResponse(status_code=400, content={"error": {"message": "input required"}})
 
-    model        = data.get("model", "gpt-4o-mini")
+    model        = data.get("model", DEFAULT_MODEL)
     tools        = data.get("tools", None)
     instructions = data.get("instructions", "")
     if instructions:
         messages.insert(0, {"role": "system", "content": instructions})
 
-    start_time = time.time()
+    start_time  = time.time()
+    model_label = _get_model_label(model)
+    prompt      = _build_prompt(messages)
+
+    print(f"[API] /v1/responses → model={model} ({model_label})")
+
     try:
-        if _is_duck(model):
-            text = await asyncio.get_event_loop().run_in_executor(
-                None, browser_engine.process_duck, DUCK_MODELS[model], messages
-            )
-        else:
-            text = await asyncio.get_event_loop().run_in_executor(
-                None, browser_engine.process_zai, format_prompt(messages, tools=tools)
-            )
+        text = await asyncio.get_event_loop().run_in_executor(
+            None, browser_engine.process, model_label, prompt
+        )
 
         p  = sum(len(_extract_content(m).split()) for m in messages)
         c  = len(text.split())
-        tc = parse_tool_calls(text) if tools else None
+        tc = _parse_tool_calls(text) if tools else None
 
         if tc:
             return {
                 "id": f"resp-{uuid.uuid4().hex[:29]}", "object": "response",
                 "created_at": int(start_time), "model": model, "status": "completed",
-                "output": [{"type": "function_call", "id": t["id"], "call_id": t["id"],
-                            "name": t["function"]["name"], "arguments": t["function"]["arguments"],
-                            "status": "completed"} for t in tc],
+                "output": [{
+                    "type": "function_call", "id": t["id"], "call_id": t["id"],
+                    "name": t["function"]["name"],
+                    "arguments": t["function"]["arguments"],
+                    "status": "completed",
+                } for t in tc],
                 "usage": {"input_tokens": p, "output_tokens": c, "total_tokens": p + c},
             }
+
         return {
             "id": f"resp-{uuid.uuid4().hex[:29]}", "object": "response",
             "created_at": int(start_time), "model": model, "status": "completed",
@@ -557,7 +460,9 @@ async def responses(request: Request):
                         "content": [{"type": "output_text", "text": text}]}],
             "usage": {"input_tokens": p, "output_tokens": c, "total_tokens": p + c},
         }
+
     except Exception as e:
+        print(f"[API] ERROR: {e}")
         return JSONResponse(status_code=500, content={"error": {"message": str(e)}})
 
 
@@ -567,9 +472,10 @@ async def list_models(request: Request):
         return JSONResponse(status_code=401, content={"error": {"message": "Invalid API Key"}})
     return {
         "object": "list",
-        "data": [{"id": m, "object": "model",
-                  "owned_by": "duck.ai" if m in DUCK_MODELS else "zai"}
-                 for m in ALL_MODELS],
+        "data": [
+            {"id": m, "object": "model", "owned_by": "duck.ai"}
+            for m in ALL_MODELS
+        ],
     }
 
 
@@ -577,10 +483,9 @@ async def list_models(request: Request):
 @app.get("/")
 async def health():
     return {
-        "status":      "running",
-        "message":     "ZAI + DuckAI API Server is active!",
-        "duck_models": list(DUCK_MODELS.keys()),
-        "zai_models":  ZAI_MODELS,
+        "status":  "running",
+        "message": "Duck.ai API Server is active!",
+        "models":  ALL_MODELS,
     }