Update main.py

main.py

@@ -5,7 +5,6 @@ import asyncio
 import threading
 import json
 import re
-import httpx
 from typing import Optional
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse, StreamingResponse
@@ -15,22 +14,22 @@ from fastapi.responses import JSONResponse, StreamingResponse
 # ====================================================================
 API_SECRET_KEY = os.getenv("API_SECRET_KEY", "change-me-secret")
 
-# ── Duck.ai models (HTTP مباشر - بدون Playwright) ──────────────────
+# ── 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-20240307":                        "claude-3-haiku-20240307",
-    "llama-4-scout":                                  "meta-llama/Llama-4-Scout-17B-16E-Instruct",
-    "meta-llama/Llama-3.3-70B-Instruct-Turbo":       "meta-llama/Llama-3.3-70B-Instruct-Turbo",
-    "mistral-small-4":                               "mistralai/Mistral-Small-3.1-24B-Instruct-2503",
-    "mistralai/Mistral-Small-24B-Instruct-2501":     "mistralai/Mistral-Small-24B-Instruct-2501",
-    "mistralai/Mixtral-8x7B-Instruct-v0.1":         "mistralai/Mixtral-8x7B-Instruct-v0.1",
+    "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 - browser scraping) ─────────────────────
+# ── 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"
@@ -38,133 +37,11 @@ ZAI_MODELS = [
 
 ALL_MODELS = list(DUCK_MODELS.keys()) + ZAI_MODELS
 
-DUCK_STATUS_URL = "https://duckduckgo.com/duckchat/v1/status"
-DUCK_CHAT_URL   = "https://duckduckgo.com/duckchat/v1/chat"
-
-DUCK_HEADERS_BASE = {
-    "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",
-    "Accept-Language": "en-US,en;q=0.9",
-    "Origin":          "https://duckduckgo.com",
-    "Referer":         "https://duckduckgo.com/",
-}
 
 # ====================================================================
-# Duck.ai HTTP Client
-# ====================================================================
-
-async def _get_vqd_token() -> str:
-    """الحصول على رمز VQD من duck.ai - مطلوب لكل محادثة جديدة"""
-    headers = {**DUCK_HEADERS_BASE, "x-vqd-accept": "1"}
-    async with httpx.AsyncClient(timeout=30) as client:
-        r = await client.get(DUCK_STATUS_URL, headers=headers)
-        token = r.headers.get("x-vqd-4", "")
-        if not token:
-            raise Exception("فشل الحصول على VQD token من duck.ai")
-        return token
-
-
-def _build_duck_messages(messages: list) -> list:
-    """تحويل messages إلى الصيغة التي تقبلها duck.ai"""
-    result = []
-    for m in messages:
-        role = m.get("role", "user")
-        # duck.ai تدعم user و assistant فقط - system يتحول لـ user
-        if role == "system":
-            role = "user"
-        if role not in ("user", "assistant"):
-            continue
-        content = _extract_content(m)
-        if content.strip():
-            result.append({"role": role, "content": content})
-    return result
-
-
-def _extract_content(msg: dict) -> str:
-    content = msg.get("content", "")
-    if isinstance(content, list):
-        parts = []
-        for item in content:
-            if isinstance(item, dict):
-                parts.append(item.get("text", item.get("content", str(item))))
-            else:
-                parts.append(str(item))
-        return "\n".join(parts)
-    return str(content) if content else ""
-
-
-async def duck_chat_complete(model: str, messages: list) -> str:
-    """استدعاء duck.ai وإرجاع النص الكامل"""
-    duck_model = DUCK_MODELS.get(model, "gpt-4o-mini")
-    vqd_token  = await _get_vqd_token()
-
-    payload = {
-        "model":    duck_model,
-        "messages": _build_duck_messages(messages),
-    }
-    headers = {
-        **DUCK_HEADERS_BASE,
-        "Content-Type": "application/json",
-        "Accept":       "text/event-stream",
-        "x-vqd-4":      vqd_token,
-    }
-
-    async with httpx.AsyncClient(timeout=120) as client:
-        r = await client.post(DUCK_CHAT_URL, json=payload, headers=headers)
-        if r.status_code == 429:
-            raise Exception("duck.ai rate limit - حاول مرة أخرى بعد قليل")
-        r.raise_for_status()
-
-        full_text = ""
-        for line in r.text.splitlines():
-            if line.startswith("data: "):
-                data = line[6:].strip()
-                if data == "[DONE]":
-                    break
-                try:
-                    chunk = json.loads(data)
-                    full_text += chunk.get("message", "")
-                except Exception:
-                    pass
-        return full_text.strip()
-
-
-async def duck_chat_stream(model: str, messages: list):
-    """استدعاء duck.ai بوضع streaming - يُرجع generator"""
-    duck_model = DUCK_MODELS.get(model, "gpt-4o-mini")
-    vqd_token  = await _get_vqd_token()
-
-    payload = {
-        "model":    duck_model,
-        "messages": _build_duck_messages(messages),
-    }
-    headers = {
-        **DUCK_HEADERS_BASE,
-        "Content-Type": "application/json",
-        "Accept":       "text/event-stream",
-        "x-vqd-4":      vqd_token,
-    }
-
-    async with httpx.AsyncClient(timeout=120) as client:
-        async with client.stream("POST", DUCK_CHAT_URL, json=payload, headers=headers) as r:
-            if r.status_code == 429:
-                raise Exception("duck.ai rate limit")
-            r.raise_for_status()
-            async for line in r.aiter_lines():
-                if line.startswith("data: "):
-                    data = line[6:].strip()
-                    if data == "[DONE]":
-                        return
-                    try:
-                        chunk = json.loads(data)
-                        token = chunk.get("message", "")
-                        if token:
-                            yield token
-                    except Exception:
-                        pass
-
-
-# ====================================================================
-# Playwright Browser Engine (ZAI models)
+# Shared Browser Engine (Playwright)
+# يستخدمه ZAI عبر chat.z.ai
+# ويستخدمه Duck.ai عبر duck.ai (متصفح حقيقي يتجاوز الحماية)
 # ====================================================================
 
 class AsyncBrowserThread(threading.Thread):
@@ -179,12 +56,12 @@ class AsyncBrowserThread(threading.Thread):
         asyncio.set_event_loop(self.loop)
         self.loop.run_until_complete(self._start_browser())
         self.ready_event.set()
-        print("[ZAI-SERVER] Browser is ready!")
+        print("[SERVER] Browser is ready!")
         self.loop.run_forever()
 
     async def _start_browser(self):
         from playwright.async_api import async_playwright
-        print("[ZAI-SERVER] Starting Chrome...")
+        print("[SERVER] Starting Chrome...")
         self.playwright = await async_playwright().start()
         self.browser = await self.playwright.chromium.launch(
             headless=True,
@@ -199,9 +76,124 @@ class AsyncBrowserThread(threading.Thread):
                 "--no-zygote",
             ],
         )
-        print("[ZAI-SERVER] Chrome launched!")
+        print("[SERVER] Chrome launched!")
+
+    # ── Duck.ai via Playwright ─────────────────────────────────────
+    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",
+            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)
+
+            # ── بناء الـ prompt من messages ────────────────────────
+            prompt = _build_duck_prompt(messages)
+
+            # ── فتح duck.ai ────────────────────────────────────────
+            await page.goto("https://duck.ai/", wait_until="domcontentloaded")
+            await asyncio.sleep(4)
+
+            # ── قبول الشروط إن ظهرت ───────────��───────────────────
+            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)
+            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)
+            await textarea.click()
+            await textarea.fill(prompt)
+            await asyncio.sleep(0.5)
+            await page.keyboard.press("Enter")
+            print(f"[DUCK] Sent ({len(prompt)} chars)")
+
+            # ── انتظار الرد ────────────────────────────────────────
+            await asyncio.sleep(3)
 
-    async def _talk_to_zai(self, prompt: str):
+            # انتظر أن يبدأ الرد
+            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)
+
+            # انتظر حتى يتوقف الرد عن التغيّر
+            last_text     = ""
+            unchanged_cnt = 0
+            while unchanged_cnt < 6:
+                current_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();
+                            }
+                        }
+                        // 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 '';
+                    }
+                """)
+                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()
+
+        except Exception as e:
+            print(f"[DUCK] Error: {e}")
+            raise e
+        finally:
+            await page.close()
+            await context.close()
+
+    # ── ZAI via Playwright ─────────────────────────────────────────
+    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},
@@ -218,7 +210,7 @@ class AsyncBrowserThread(threading.Thread):
             await page.fill("textarea#chat-input", prompt)
             await asyncio.sleep(0.5)
             await page.press("textarea#chat-input", "Enter")
-            print(f"[ZAI-SERVER] Sent ({len(prompt)} chars)")
+            print(f"[ZAI] Sent ({len(prompt)} chars)")
             await asyncio.sleep(2)
             await page.wait_for_selector("#response-content-container", timeout=120000)
             last_text     = ""
@@ -241,16 +233,25 @@ class AsyncBrowserThread(threading.Thread):
                     last_text     = current_text
                     unchanged_cnt = 0
                 await asyncio.sleep(1.0)
-            print(f"[ZAI-SERVER] Response: {len(last_text)} chars")
+            print(f"[ZAI] Response: {len(last_text)} chars")
             return last_text.strip()
         except Exception as e:
-            print(f"[ZAI-SERVER] Error: {e}")
+            print(f"[ZAI] Error: {e}")
             raise e
         finally:
             await page.close()
             await context.close()
 
-    def process_request(self, prompt: str):
+    # ── Public methods ─────────────────────────────────────────────
+    def process_duck(self, model_id: str, messages: list) -> str:
+        if not self.ready_event.wait(timeout=60):
+            raise Exception("Browser not 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")
         future = asyncio.run_coroutine_threadsafe(self._talk_to_zai(prompt), self.loop)
@@ -262,9 +263,48 @@ browser_engine.start()
 
 
 # ====================================================================
-# Prompt Builder (للـ ZAI models - محفوظ بالكامل)
+# Prompt Helpers
 # ====================================================================
 
+def _extract_content(msg: dict) -> str:
+    content = msg.get("content", "")
+    if isinstance(content, list):
+        parts = []
+        for item in content:
+            if isinstance(item, dict):
+                parts.append(item.get("text", item.get("content", str(item))))
+            else:
+                parts.append(str(item))
+        return "\n".join(parts)
+    return str(content) if content else ""
+
+
+def _build_duck_prompt(messages: list) -> str:
+    """
+    يبني prompt نصي من messages لإرساله لـ duck.ai
+    يدمج system + history + السؤال الأخير
+    """
+    parts = []
+    for msg in messages:
+        role    = msg.get("role", "user")
+        content = _extract_content(msg)
+        if not content.strip():
+            continue
+        if role == "system":
+            parts.append(f"[INSTRUCTIONS]: {content}")
+        elif role == "assistant":
+            parts.append(f"[Previous AI response]: {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".join(parts)
+
+
 def format_prompt(messages, tools=None):
     parts        = []
     system_parts = []
@@ -274,16 +314,7 @@ def format_prompt(messages, tools=None):
     for msg in messages:
         role     = msg.get("role", "")
         msg_type = msg.get("type", "")
-        content  = msg.get("content", "")
-
-        if isinstance(content, list):
-            text_parts = []
-            for item in content:
-                if isinstance(item, dict):
-                    text_parts.append(item.get("text", item.get("content", str(item))))
-                else:
-                    text_parts.append(str(item))
-            content = "\n".join(text_parts)
+        content  = _extract_content(msg)
 
         if role == "system":
             system_parts.append(content)
@@ -301,8 +332,8 @@ def format_prompt(messages, tools=None):
             func_args = msg.get("arguments", "{}")
             parts.append(f"[PREVIOUS TOOL CALL: Called '{func_name}' with arguments: {func_args}]")
         elif role == "assistant":
-            assistant_content  = content if content else ""
-            tool_calls_in_msg  = msg.get("tool_calls", [])
+            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:
@@ -326,7 +357,7 @@ def format_prompt(messages, tools=None):
             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)
+        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"
@@ -340,7 +371,7 @@ def format_prompt(messages, tools=None):
     return final
 
 
-def format_tools_instruction(tools, user_question=""):
+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"
@@ -349,7 +380,6 @@ def format_tools_instruction(tools, user_question=""):
     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"
-
     for tool in tools:
         func   = tool.get("function", tool)
         name   = func.get("name", "unknown")
@@ -365,7 +395,6 @@ def format_tools_instruction(tools, user_question=""):
                 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")
@@ -380,12 +409,10 @@ def parse_tool_calls(response_text):
         m = re.search(r'```(?:json)?\s*\n?(.*?)\n?\s*```', cleaned, re.DOTALL)
         if m:
             cleaned = m.group(1).strip()
-
     candidates = [cleaned]
     m2 = re.search(r'\{[\s\S]*"tool_calls"[\s\S]*\}', cleaned)
     if m2:
         candidates.append(m2.group(0))
-
     for candidate in candidates:
         try:
             parsed = json.loads(candidate)
@@ -394,8 +421,8 @@ def parse_tool_calls(response_text):
                 if isinstance(raw_calls, list) and raw_calls:
                     formatted = []
                     for call in raw_calls:
-                        tool_name = call.get("name", "")
-                        arguments = call.get("arguments", {})
+                        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]}",
@@ -409,19 +436,19 @@ def parse_tool_calls(response_text):
 
 
 # ====================================================================
-# Helpers
+# Auth & Response Builder
 # ====================================================================
 
-def _is_duck_model(model: str) -> bool:
-    return model in DUCK_MODELS
-
-
 def _auth(request: Request) -> bool:
     auth = request.headers.get("authorization", "")
     return auth.replace("Bearer ", "").strip() == API_SECRET_KEY
 
 
-def _build_response(start_time, model, response_text, messages, tools, is_duck):
+def _is_duck_model(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
@@ -455,7 +482,6 @@ def _build_response(start_time, model, response_text, messages, tools, is_duck):
 app = FastAPI(title="ZAI + DuckAI API Server")
 
 
-# ── POST /v1/chat/completions ──────────────────────────────────────
 @app.post("/v1/chat/completions")
 async def chat_completions(request: Request):
     try:
@@ -472,48 +498,29 @@ async def chat_completions(request: Request):
 
     model      = data.get("model", "gpt-4o-mini")
     tools      = data.get("tools", None)
-    do_stream  = data.get("stream", False)
     start_time = time.time()
 
     try:
-        # ── Duck.ai path ──────────────────────────────────────────
         if _is_duck_model(model):
-            if do_stream:
-                chunk_id = f"chatcmpl-{uuid.uuid4().hex[:29]}"
-
-                async def event_stream():
-                    async for token in duck_chat_stream(model, messages):
-                        chunk = {
-                            "id": chunk_id, "object": "chat.completion.chunk",
-                            "created": int(start_time), "model": model,
-                            "choices": [{"index": 0, "delta": {"content": token}, "finish_reason": None}],
-                        }
-                        yield f"data: {json.dumps(chunk)}\n\n"
-                    final = {
-                        "id": chunk_id, "object": "chat.completion.chunk",
-                        "created": int(start_time), "model": model,
-                        "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}],
-                    }
-                    yield f"data: {json.dumps(final)}\n\n"
-                    yield "data: [DONE]\n\n"
-
-                return StreamingResponse(event_stream(), media_type="text/event-stream")
-
-            response_text = await duck_chat_complete(model, messages)
-            return _build_response(start_time, model, response_text, messages, tools, is_duck=True)
-
-        # ── ZAI (Playwright) path ─────────────────────────────────
+            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
+            )
         else:
-            prompt        = format_prompt(messages, tools=tools)
-            print(f"[ZAI-SERVER] Processing ({len(prompt)} chars)")
-            response_text = browser_engine.process_request(prompt)
-            return _build_response(start_time, model, response_text, messages, tools, is_duck=False)
+            prompt = format_prompt(messages, tools=tools)
+            print(f"[SERVER] ZAI request ({len(prompt)} chars)")
+            response_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)
 
     except Exception as e:
+        print(f"[SERVER] Error: {e}")
         return JSONResponse(status_code=500, content={"error": {"message": str(e)}})
 
 
-# ── POST /v1/responses ────────────────────────────────────────────
 @app.post("/v1/responses")
 async def responses(request: Request):
     try:
@@ -545,26 +552,29 @@ async def responses(request: Request):
 
     try:
         if _is_duck_model(model):
-            response_text = await duck_chat_complete(model, messages)
+            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
+            )
         else:
             prompt        = format_prompt(messages, tools=tools)
-            response_text = browser_engine.process_request(prompt)
+            response_text = await asyncio.get_event_loop().run_in_executor(
+                None, browser_engine.process_zai, prompt
+            )
 
         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 = []
-            for tc in tool_calls:
-                output_items.append({
-                    "type":      "function_call",
-                    "id":        tc["id"],
-                    "call_id":   tc["id"],
-                    "name":      tc["function"]["name"],
-                    "arguments": tc["function"]["arguments"],
-                    "status":    "completed",
-                })
+            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]
             return {
                 "id": f"resp-{uuid.uuid4().hex[:29]}", "object": "response",
                 "created_at": int(start_time), "model": model, "status": "completed",
@@ -586,7 +596,6 @@ async def responses(request: Request):
         return JSONResponse(status_code=500, content={"error": {"message": str(e)}})
 
 
-# ── GET /v1/models ────────────────────────────────────────────────
 @app.get("/v1/models")
 async def list_models(request: Request):
     if not _auth(request):
@@ -594,17 +603,13 @@ async def list_models(request: Request):
     return {
         "object": "list",
         "data": [
-            {
-                "id":       m,
-                "object":   "model",
-                "owned_by": "duck.ai" if m in DUCK_MODELS else "zai",
-            }
+            {"id": m, "object": "model",
+             "owned_by": "duck.ai" if m in DUCK_MODELS else "zai"}
             for m in ALL_MODELS
         ],
     }
 
 
-# ��─ GET /health  &  GET / ─────────────────────────────────────────
 @app.get("/health")
 @app.get("/")
 async def health_check():
@@ -618,4 +623,4 @@ async def health_check():
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=7860)