Update main.py

main.py

@@ -5,31 +5,27 @@ import asyncio
 import threading
 import json
 import re
-from typing import Optional
 from fastapi import FastAPI, Request
-from fastapi.responses import JSONResponse, StreamingResponse
+from fastapi.responses import JSONResponse
 
 # ====================================================================
 # Configuration
 # ====================================================================
 API_SECRET_KEY = os.getenv("API_SECRET_KEY", "change-me-secret")
 
-# ── Duck.ai models ─────────────────────────────────────────────────
-# الـ key هو ما يرسله المستخدم، الـ value هو ID النموذج في 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-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",
 }
 
-# ── ZAI models (Playwright → chat.z.ai) ───────────────────────────
 ZAI_MODELS = [
     "GLM-5.1", "GLM-5-Turbo", "GLM-5V-Turbo",
     "GLM-5", "GLM-4.7", "GLM-4.6V", "GLM-4.5-Air"
@@ -37,11 +33,8 @@ ZAI_MODELS = [
 
 ALL_MODELS = list(DUCK_MODELS.keys()) + ZAI_MODELS
 
-
 # ====================================================================
-# Shared Browser Engine (Playwright)
-# يستخدمه ZAI عبر chat.z.ai
-# ويستخدمه Duck.ai عبر duck.ai (متصفح حقيقي يتجاوز الحماية)
+# Browser Engine
 # ====================================================================
 
 class AsyncBrowserThread(threading.Thread):
@@ -78,15 +71,16 @@ class AsyncBrowserThread(threading.Thread):
         )
         print("[SERVER] Chrome launched!")
 
-    # ── Duck.ai via Playwright ─────────────────────────────────────
+    # ────────────────────────────────────────────────────────────────
+    # Duck.ai
+    # ────────────────────────────────────────────────────────────────
     async def _talk_to_duck(self, model_id: str, messages: list) -> str:
-        """
-        يفتح duck.ai في المتصفح الحقيقي ويرسل الرسالة
-        model_id: القيمة من DUCK_MODELS dict
-        messages: قائمة OpenAI messages
-        """
         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",
+            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(
@@ -95,95 +89,115 @@ class AsyncBrowserThread(threading.Thread):
         page = await context.new_page()
         try:
             page.set_default_timeout(120000)
-
-            # ── بناء الـ prompt من messages ────────────────────────
             prompt = _build_duck_prompt(messages)
 
-            # ── فتح duck.ai ────────────────────────────────────────
-            await page.goto("https://duck.ai/", wait_until="domcontentloaded")
-            await asyncio.sleep(4)
+            # ── 1. فتح الصفحة ──────────────────────────────────────
+            await page.goto("https://duckduckgo.com/aichat", wait_until="domcontentloaded")
+            await asyncio.sleep(5)
 
-            # ── قبول الشروط إن ظهرت ──────────────────────��────────
+            # ── 2. قبول الشروط إن ظهرت ────────────────────────────
             try:
-                accept_btn = page.locator("button:has-text('Accept'), button:has-text('Get Started'), button:has-text('Start chatting')")
-                if await accept_btn.count() > 0:
-                    await accept_btn.first.click()
-                    await asyncio.sleep(2)
+                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
             except Exception:
                 pass
 
-            # ── اختيار النموذج المطلوب ─────────────────────────────
-            # duck.ai يعرض نموذجاً افتراضياً - نحتاج تغييره إذا كان مختلفاً
-            try:
-                model_btn = page.locator("[data-testid='model-selector'], button[aria-label*='model'], button[aria-label*='Model'], .model-selector")
-                if await model_btn.count() > 0:
-                    await model_btn.first.click()
-                    await asyncio.sleep(1)
-                    # البحث عن النموذج المطلوب في القائمة
-                    model_option = page.locator(f"[data-value='{model_id}'], [value='{model_id}'], li:has-text('{model_id.split('/')[-1]}')")
-                    if await model_option.count() > 0:
-                        await model_option.first.click()
-                        await asyncio.sleep(1)
-                    else:
-                        # إغلاق القائمة إذا لم يجد النموذج
-                        await page.keyboard.press("Escape")
-            except Exception as e:
-                print(f"[DUCK] Model selection skipped: {e}")
-
-            # ── إرسال الرسالة ──────────────────────────────────────
-            textarea = page.locator("textarea, [contenteditable='true'], [role='textbox']").first
-            await textarea.wait_for(state="visible", timeout=30000)
+            # ── 3. الانتظار حتى يظهر صندوق الكتابة ────────────────
+            # الـ selector المثبت من مصادر حقيقية
+            await page.wait_for_selector("textarea[name='user-prompt']", timeout=30000)
+
+            # ── 4. إرسال الرسالة ───────────────────────────────────
+            textarea = page.locator("textarea[name='user-prompt']")
             await textarea.click()
             await textarea.fill(prompt)
             await asyncio.sleep(0.5)
-            await page.keyboard.press("Enter")
-            print(f"[DUCK] Sent ({len(prompt)} chars)")
 
-            # ── انتظار الرد ────────────────────────────────────────
+            # إيجاد زر الإرسال والضغط عليه
+            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)")
+
+            # ── 5. انتظار بدء الرد ────────────────────────────────
             await asyncio.sleep(3)
 
-            # انتظر أن يبدأ الرد
-            response_selector = "[data-testid='message-assistant'], .message-content, .chat-message-content, [class*='AssistantMessage'], [class*='assistant-message']"
-            await page.wait_for_selector(response_selector, timeout=60000)
+            # انتظر وقف المؤشر الوامض (يعني انتهى الرد)
+            # duck.ai يضيف data-copyairesponse على زر النسخ عند اكتمال الرد
+            try:
+                await page.wait_for_selector(
+                    "button[data-copyairesponse='true']",
+                    timeout=90000
+                )
+                await asyncio.sleep(1)
+            except Exception:
+                # fallback: انتظر ثابت
+                await asyncio.sleep(15)
+
+            # ── 6. استخراج النص ───────────────────────────────────
+            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();
+                    }
 
-            # انتظر حتى يتوقف الرد عن التغيّر
-            last_text     = ""
-            unchanged_cnt = 0
-            while unchanged_cnt < 6:
-                current_text = await page.evaluate("""
+                    // fallback: كل العناصر التي تبدو كردود AI
+                    const allArticles = document.querySelectorAll('article, [role="article"]');
+                    if (allArticles.length > 0) {
+                        const last = allArticles[allArticles.length - 1];
+                        return last.innerText.trim();
+                    }
+
+                    // آخر حل: أخذ كل النصوص الطويلة
+                    const divs = [...document.querySelectorAll('div')].filter(d =>
+                        d.children.length < 5 &&
+                        d.innerText &&
+                        d.innerText.trim().length > 100
+                    );
+                    if (divs.length > 0) return divs[divs.length - 1].innerText.trim();
+                    return '';
+                }
+            """)
+
+            # إذا كان النص فارغاً، انتظر أكثر وحاول مرة ثانية
+            if not response_text or len(response_text.strip()) < 5:
+                await asyncio.sleep(8)
+                response_text = await page.evaluate("""
                     () => {
-                        // محاولة عدة selectors
-                        const selectors = [
-                            '[data-testid="message-assistant"]:last-child',
-                            '.chat-message--assistant:last-child',
-                            '[class*="AssistantMessage"]:last-child',
-                            '[class*="assistant"]:last-child [class*="content"]',
-                        ];
-                        for (const sel of selectors) {
-                            const el = document.querySelector(sel);
-                            if (el && el.innerText && el.innerText.trim().length > 0) {
-                                return el.innerText.trim();
+                        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;
                             }
                         }
-                        // fallback: آخر رسالة في المحادثة
-                        const allMsgs = document.querySelectorAll(
-                            '[class*="message"]:not([class*="user"]):not([class*="User"])'
-                        );
-                        if (allMsgs.length > 0) {
-                            return allMsgs[allMsgs.length - 1].innerText.trim();
-                        }
-                        return '';
+                        return document.body.innerText.slice(0, 3000);
                     }
                 """)
-                if current_text == last_text and current_text.strip():
-                    unchanged_cnt += 1
-                else:
-                    last_text     = current_text
-                    unchanged_cnt = 0
-                await asyncio.sleep(1.2)
 
-            print(f"[DUCK] Response: {len(last_text)} chars")
-            return last_text.strip()
+            print(f"[DUCK] Response: {len(response_text)} chars")
+            return response_text.strip()
 
         except Exception as e:
             print(f"[DUCK] Error: {e}")
@@ -192,10 +206,16 @@ class AsyncBrowserThread(threading.Thread):
             await page.close()
             await context.close()
 
-    # ── ZAI via Playwright ─────────────────────────────────────────
+    # ────────────────────���───────────────────────────────────────────
+    # 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",
+            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(
@@ -242,18 +262,22 @@ class AsyncBrowserThread(threading.Thread):
             await page.close()
             await context.close()
 
-    # ── Public methods ─────────────────────────────────────────────
-    def process_duck(self, model_id: str, messages: list) -> str:
+    # ────────────────────────────────────────────────────────────────
+    # Public blocking methods
+    # ────────────────────────────────────────────────────────────────
+    def _wait_ready(self):
         if not self.ready_event.wait(timeout=60):
-            raise Exception("Browser not ready")
+            raise Exception("Browser not ready after 60s")
+
+    def process_duck(self, model_id: str, messages: list) -> str:
+        self._wait_ready()
         future = asyncio.run_coroutine_threadsafe(
             self._talk_to_duck(model_id, messages), self.loop
         )
         return future.result(timeout=180)
 
     def process_zai(self, prompt: str) -> str:
-        if not self.ready_event.wait(timeout=60):
-            raise Exception("Browser not ready")
+        self._wait_ready()
         future = asyncio.run_coroutine_threadsafe(self._talk_to_zai(prompt), self.loop)
         return future.result(timeout=120)
 
@@ -280,10 +304,6 @@ def _extract_content(msg: dict) -> str:
 
 
 def _build_duck_prompt(messages: list) -> str:
-    """
-    يبني prompt نصي من messages لإرساله لـ duck.ai
-    يدمج system + history + السؤال الأخير
-    """
     parts = []
     for msg in messages:
         role    = msg.get("role", "user")
@@ -291,23 +311,19 @@ def _build_duck_prompt(messages: list) -> str:
         if not content.strip():
             continue
         if role == "system":
-            parts.append(f"[INSTRUCTIONS]: {content}")
+            parts.append(f"[INSTRUCTIONS]:\n{content}")
         elif role == "assistant":
-            parts.append(f"[Previous AI response]: {content}")
+            parts.append(f"[Previous AI response]:\n{content}")
         else:
             parts.append(content)
-
-    # الرسالة الأخيرة فقط هي السؤال الفعلي
     if len(parts) > 1:
-        context = "\n\n".join(parts[:-1])
-        question = parts[-1]
-        return f"{context}\n\n---\n\n{question}"
+        return "\n\n---\n\n".join(parts)
     return "\n\n".join(parts)
 
 
 def format_prompt(messages, tools=None):
-    parts        = []
-    system_parts = []
+    parts            = []
+    system_parts     = []
     has_tool_results = False
     user_question    = ""
 
@@ -320,28 +336,20 @@ def format_prompt(messages, tools=None):
             system_parts.append(content)
         elif role == "tool":
             has_tool_results = True
-            tool_name = msg.get("name", "tool")
-            parts.append(f"[TOOL RESULT from '{tool_name}']:\n{content}")
+            parts.append(f"[TOOL RESULT from '{msg.get('name','tool')}']:\n{content}")
         elif msg_type == "function_call_output":
             has_tool_results = True
-            call_id        = msg.get("call_id", "")
-            output_content = msg.get("output", content)
-            parts.append(f"[TOOL RESULT (call_id: {call_id})]:\n{output_content}")
+            parts.append(f"[TOOL RESULT (call_id: {msg.get('call_id','')})]:\n{msg.get('output', content)}")
         elif msg_type == "function_call":
-            func_name = msg.get("name", "?")
-            func_args = msg.get("arguments", "{}")
-            parts.append(f"[PREVIOUS TOOL CALL: Called '{func_name}' with arguments: {func_args}]")
+            parts.append(f"[PREVIOUS TOOL CALL: Called '{msg.get('name','?')}' with arguments: {msg.get('arguments','{}')}]")
         elif role == "assistant":
-            assistant_content = content
-            tool_calls_in_msg = msg.get("tool_calls", [])
-            if tool_calls_in_msg:
-                tc_desc = []
-                for tc in tool_calls_in_msg:
-                    func = tc.get("function", {})
-                    tc_desc.append(f"Called '{func.get('name','?')}' with: {func.get('arguments','{}')}")
-                assistant_content += "\n[Previous tool calls: " + "; ".join(tc_desc) + "]"
-            if assistant_content.strip():
-                parts.append(f"[Assistant]: {assistant_content}")
+            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
@@ -355,52 +363,36 @@ def format_prompt(messages, tools=None):
             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 ===\nThe following information was retrieved by the tools you requested.\nUse ONLY this information to answer the user's question.\n\n"
-
+        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 ===\nNow answer the user's question based ONLY on the tool results above.\n"
-
+        final += "\n\n=== INSTRUCTION ===\nAnswer based ONLY on tool results above.\n"
     return final
 
 
 def _format_tools_instruction(tools, user_question=""):
-    instruction  = "\n=== MANDATORY TOOL USAGE ===\n"
-    instruction += "You MUST use one of the tools below to answer this question.\n"
-    instruction += "Do NOT answer directly. Do NOT say you don't have information.\n"
-    instruction += "You MUST respond with ONLY a JSON object to call the tool.\n\n"
-    instruction += 'RESPONSE FORMAT - respond with ONLY this JSON, nothing else:\n'
-    instruction += '{"tool_calls": [{"name": "TOOL_NAME", "arguments": {"param": "value"}}]}\n\n'
-    instruction += "RULES:\n- Your ENTIRE response must be valid JSON only\n- No markdown, no code blocks, no explanation\n- No text before or after the JSON\n\n"
-    instruction += "Available tools:\n\n"
+    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)
-        name   = func.get("name", "unknown")
-        desc   = func.get("description", "No description")
+        func = tool.get("function", tool)
+        i += f"Tool: {func.get('name','unknown')}\nDescription: {func.get('description','')}\n"
         params = func.get("parameters", {})
-        instruction += f"Tool: {name}\nDescription: {desc}\n"
         if params.get("properties"):
-            instruction += "Parameters:\n"
-            required_params = params.get("required", [])
-            for pname, pinfo in params["properties"].items():
-                ptype = pinfo.get("type", "string")
-                pdesc = pinfo.get("description", "")
-                req   = "required" if pname in required_params else "optional"
-                instruction += f"  - {pname} ({ptype}, {req}): {pdesc}\n"
-        instruction += "\n"
-    instruction += "=== END OF TOOLS ===\n\n"
-    first_func = (tools[0] if tools else {}).get("function", tools[0] if tools else {})
-    first_name = first_func.get("name", "tool")
-    instruction += f'EXAMPLE:\n{{"tool_calls": [{{"name": "{first_name}", "arguments": {{"input": "the user question here"}}}}]}}\n\n'
-    instruction += "Now respond with the JSON to call the appropriate tool:\n\n"
-    return instruction
+            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):
@@ -413,71 +405,62 @@ def parse_tool_calls(response_text):
     m2 = re.search(r'\{[\s\S]*"tool_calls"[\s\S]*\}', cleaned)
     if m2:
         candidates.append(m2.group(0))
-    for candidate in candidates:
+    for c in candidates:
         try:
-            parsed = json.loads(candidate)
+            parsed = json.loads(c)
             if isinstance(parsed, dict) and "tool_calls" in parsed:
-                raw_calls = parsed["tool_calls"]
-                if isinstance(raw_calls, list) and raw_calls:
-                    formatted = []
-                    for call in raw_calls:
-                        tool_name     = call.get("name", "")
-                        arguments     = call.get("arguments", {})
-                        arguments_str = json.dumps(arguments, ensure_ascii=False) if isinstance(arguments, dict) else str(arguments)
-                        formatted.append({
-                            "id":       f"call_{uuid.uuid4().hex[:24]}",
-                            "type":     "function",
-                            "function": {"name": tool_name, "arguments": arguments_str},
-                        })
-                    return formatted
+                raw = parsed["tool_calls"]
+                if isinstance(raw, list) and raw:
+                    return [{
+                        "id": f"call_{uuid.uuid4().hex[:24]}",
+                        "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", "{}"))
+                        }
+                    } for call in raw]
         except (json.JSONDecodeError, TypeError, KeyError):
             continue
     return None
 
 
 # ====================================================================
-# Auth & Response Builder
+# Auth & Shared response builder
 # ====================================================================
 
 def _auth(request: Request) -> bool:
-    auth = request.headers.get("authorization", "")
-    return auth.replace("Bearer ", "").strip() == API_SECRET_KEY
+    return request.headers.get("authorization", "").replace("Bearer ", "").strip() == API_SECRET_KEY
 
 
-def _is_duck_model(model: str) -> bool:
+def _is_duck(model: str) -> bool:
     return model in DUCK_MODELS
 
 
-def _make_completion(start_time, model, response_text, messages, tools):
-    p_tokens   = sum(len(_extract_content(m).split()) for m in messages)
-    c_tokens   = len(response_text.split())
-    tool_calls = parse_tool_calls(response_text) if tools else None
-
-    if tool_calls:
+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
+    if tc:
         return {
-            "id":      f"chatcmpl-{uuid.uuid4().hex[:29]}",
-            "object":  "chat.completion",
-            "created": int(start_time),
-            "model":   model,
+            "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": tool_calls}, "finish_reason": "tool_calls"}],
-            "usage":   {"prompt_tokens": p_tokens, "completion_tokens": c_tokens,
-                        "total_tokens": p_tokens + c_tokens},
+                         "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": response_text},
+        "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_tokens, "completion_tokens": c_tokens,
-                    "total_tokens": p_tokens + c_tokens},
+        "usage": {"prompt_tokens": p, "completion_tokens": c, "total_tokens": p + c},
     }
 
 
 # ====================================================================
-# FastAPI App
+# FastAPI
 # ====================================================================
 app = FastAPI(title="ZAI + DuckAI API Server")
 
@@ -487,37 +470,34 @@ async def chat_completions(request: Request):
     try:
         data = await request.json()
     except Exception:
-        return JSONResponse(status_code=400, content={"error": {"message": "Invalid JSON payload"}})
-
+        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"}})
 
     messages = data.get("messages", [])
     if not messages:
-        return JSONResponse(status_code=400, content={"error": {"message": "messages field is required"}})
+        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()
 
     try:
-        if _is_duck_model(model):
-            duck_model_id = DUCK_MODELS[model]
-            print(f"[SERVER] Duck.ai request → {duck_model_id}")
-            response_text = await asyncio.get_event_loop().run_in_executor(
-                None, browser_engine.process_duck, duck_model_id, messages
+        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 request ({len(prompt)} chars)")
-            response_text = await asyncio.get_event_loop().run_in_executor(
+            print(f"[SERVER] zai → {len(prompt)} chars")
+            text = await asyncio.get_event_loop().run_in_executor(
                 None, browser_engine.process_zai, prompt
             )
-
-        return _make_completion(start_time, model, response_text, messages, tools)
-
+        return _completion_response(start_time, model, text, messages, tools)
     except Exception as e:
-        print(f"[SERVER] Error: {e}")
+        print(f"[SERVER] ERROR: {e}")
         return JSONResponse(status_code=500, content={"error": {"message": str(e)}})
 
 
@@ -526,8 +506,7 @@ async def responses(request: Request):
     try:
         data = await request.json()
     except Exception:
-        return JSONResponse(status_code=400, content={"error": {"message": "Invalid JSON payload"}})
-
+        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"}})
 
@@ -538,9 +517,8 @@ 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 field is required"}})
+        return JSONResponse(status_code=400, content={"error": {"message": "input required"}})
 
     model        = data.get("model", "gpt-4o-mini")
     tools        = data.get("tools", None)
@@ -549,49 +527,36 @@ async def responses(request: Request):
         messages.insert(0, {"role": "system", "content": instructions})
 
     start_time = time.time()
-
     try:
-        if _is_duck_model(model):
-            duck_model_id = DUCK_MODELS[model]
-            response_text = await asyncio.get_event_loop().run_in_executor(
-                None, browser_engine.process_duck, duck_model_id, messages
+        if _is_duck(model):
+            text = await asyncio.get_event_loop().run_in_executor(
+                None, browser_engine.process_duck, DUCK_MODELS[model], messages
             )
         else:
-            prompt        = format_prompt(messages, tools=tools)
-            response_text = await asyncio.get_event_loop().run_in_executor(
-                None, browser_engine.process_zai, prompt
+            text = await asyncio.get_event_loop().run_in_executor(
+                None, browser_engine.process_zai, format_prompt(messages, tools=tools)
             )
 
-        p_tokens   = sum(len(_extract_content(m).split()) for m in messages)
-        c_tokens   = len(response_text.split())
-        tool_calls = parse_tool_calls(response_text) if tools else None
-
-        if tool_calls:
-            output_items = [{
-                "type":      "function_call",
-                "id":        tc["id"],
-                "call_id":   tc["id"],
-                "name":      tc["function"]["name"],
-                "arguments": tc["function"]["arguments"],
-                "status":    "completed",
-            } for tc in tool_calls]
+        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"resp-{uuid.uuid4().hex[:29]}", "object": "response",
                 "created_at": int(start_time), "model": model, "status": "completed",
-                "output": output_items,
-                "usage": {"input_tokens": p_tokens, "output_tokens": c_tokens,
-                          "total_tokens": p_tokens + c_tokens},
+                "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",
             "output": [{"type": "message", "role": "assistant",
-                        "content": [{"type": "output_text", "text": response_text}]}],
-            "usage": {"input_tokens": p_tokens, "output_tokens": c_tokens,
-                      "total_tokens": p_tokens + c_tokens},
+                        "content": [{"type": "output_text", "text": text}]}],
+            "usage": {"input_tokens": p, "output_tokens": c, "total_tokens": p + c},
         }
-
     except Exception as e:
         return JSONResponse(status_code=500, content={"error": {"message": str(e)}})
 
@@ -602,17 +567,15 @@ 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" if m in DUCK_MODELS else "zai"}
+                 for m in ALL_MODELS],
     }
 
 
 @app.get("/health")
 @app.get("/")
-async def health_check():
+async def health():
     return {
         "status":      "running",
         "message":     "ZAI + DuckAI API Server is active!",