Update main.py

main.py

@@ -11,7 +11,8 @@ from fastapi.responses import JSONResponse
 # ====================================================================
 # Configuration
 # ====================================================================
-API_SECRET_KEY = os.getenv("API_SECRET_KEY", "change-me-secret")
+API_SECRET_KEY  = os.getenv("API_SECRET_KEY", "change-me-secret")
+POOL_SIZE       = int(os.getenv("POOL_SIZE", "3"))   # عدد المتصفحات المتوازية
 
 DUCK_MODELS = {
     "gpt-5-mini":       "GPT-5 mini",
@@ -27,44 +28,39 @@ DUCK_MODELS = {
 ALL_MODELS    = list(DUCK_MODELS.keys())
 DEFAULT_MODEL = "gpt-5-mini"
 
+
 # ====================================================================
-# Browser Engine
+# Single Browser Worker
 # ====================================================================
 
-class AsyncBrowserThread(threading.Thread):
-    def __init__(self):
-        super().__init__(daemon=True)
-        self.loop               = asyncio.new_event_loop()
-        self.ready_event        = threading.Event()
-        self.browser            = None
-        self.playwright         = None
-        self.persistent_context = None
-
-    def run(self):
-        asyncio.set_event_loop(self.loop)
-        self.loop.run_until_complete(self._start_browser())
-        self.ready_event.set()
-        print("[SERVER] Browser + Duck.ai ready!")
-        self.loop.run_forever()
+class BrowserWorker:
+    """
+    متصفح مستقل كامل — context + قبول الشروط.
+    كل worker يعمل بشكل مستقل تماماً عن البقية.
+    """
 
-    async def _start_browser(self):
-        from playwright.async_api import async_playwright
-        print("[SERVER] Launching Chrome...")
-        self.playwright = await async_playwright().start()
-        self.browser = await self.playwright.chromium.launch(
+    def __init__(self, worker_id: int, loop: asyncio.AbstractEventLoop):
+        self.id      = worker_id
+        self.loop    = loop
+        self.context = None
+        self.busy    = False
+        self._lock   = asyncio.Lock()
+
+    def tag(self, msg: str) -> str:
+        return f"[W{self.id}] {msg}"
+
+    async def init(self, playwright):
+        browser = await playwright.chromium.launch(
             headless=True,
             channel="chrome",
             args=[
                 "--disable-blink-features=AutomationControlled",
-                "--no-sandbox",
-                "--disable-gpu",
-                "--disable-dev-shm-usage",
-                "--disable-setuid-sandbox",
-                "--single-process",
-                "--no-zygote",
+                "--no-sandbox", "--disable-gpu",
+                "--disable-dev-shm-usage", "--disable-setuid-sandbox",
+                "--single-process", "--no-zygote",
             ],
         )
-        self.persistent_context = await self.browser.new_context(
+        self.context = await browser.new_context(
             user_agent=(
                 "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                 "AppleWebKit/537.36 (KHTML, like Gecko) "
@@ -72,106 +68,124 @@ class AsyncBrowserThread(threading.Thread):
             ),
             viewport={"width": 1920, "height": 1080},
         )
-        await self.persistent_context.add_init_script(
-            "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
+        await self.context.add_init_script(
+            "Object.defineProperty(navigator,'webdriver',{get:()=>undefined})"
         )
-        # قبول الشروط مرة واحدة
-        setup_page = await self.persistent_context.new_page()
+
+        # قبول الشروط
+        page = await self.context.new_page()
         try:
-            print("[SERVER] Opening duck.ai for setup...")
-            await setup_page.goto(
-                "https://duckduckgo.com/aichat", wait_until="domcontentloaded"
-            )
+            print(self.tag("Opening duck.ai for setup..."))
+            await page.goto("https://duckduckgo.com/aichat", wait_until="domcontentloaded")
             await asyncio.sleep(5)
-            agree_btn = setup_page.locator('button:has-text("Agree and Continue")')
-            await agree_btn.wait_for(state="visible", timeout=12000)
-            await agree_btn.click()
-            print("[SERVER] Terms accepted ✓")
+            agree = page.locator('button:has-text("Agree and Continue")')
+            await agree.wait_for(state="visible", timeout=15000)
+            await agree.click()
+            print(self.tag("Terms accepted ✓"))
             await asyncio.sleep(3)
-            await setup_page.wait_for_selector(
-                'textarea[name="user-prompt"]', timeout=20000
-            )
-            print("[SERVER] Interface ready ✓")
+            await page.wait_for_selector('textarea[name="user-prompt"]', timeout=20000)
+            print(self.tag("Ready ✓"))
         except Exception as e:
-            print(f"[SERVER] Setup note: {e}")
+            print(self.tag(f"Setup note: {e}"))
         finally:
-            await setup_page.close()
+            await page.close()
 
-    async def _select_model(self, page, model_label: str):
-        """
-        تغيير النموذج عبر:
-        1. Ctrl+Alt+M لفتح قائمة النماذج
-        2. اختيار النموذج
-        3. الضغط على "Start chat"
-        """
+    async def chat(self, model_label: str, prompt: str) -> str:
+        async with self._lock:
+            self.busy = True
+            try:
+                return await self._do_chat(model_label, prompt)
+            finally:
+                self.busy = False
+
+    async def _do_chat(self, model_label: str, prompt: str) -> str:
+        page = await self.context.new_page()
         try:
-            model_btn = page.locator('button[data-testid="model-select-button"]')
-            current_text = (await model_btn.inner_text()).strip()
-            print(f"[DUCK] Current model: {current_text}")
+            page.set_default_timeout(180000)
 
-            if model_label.lower() in current_text.lower():
-                print(f"[DUCK] Model already correct ✓")
-                return True
+            # ── 1. فتح الصفحة ──────────────────────────────────
+            await page.goto("https://duckduckgo.com/aichat", wait_until="domcontentloaded")
+            await asyncio.sleep(3)
 
-            # فتح قائمة النماذج
-            await model_btn.click()
+            # ── 2. Popup احتياطي ────────────────────────────────
+            try:
+                agree = page.locator('button:has-text("Agree and Continue")')
+                if await agree.count() > 0 and await agree.first.is_visible():
+                    await agree.first.click()
+                    await asyncio.sleep(2)
+            except Exception:
+                pass
+
+            # ── 3. انتظار textarea ──────────────────────────────
+            await page.wait_for_selector('textarea[name="user-prompt"]')
+            print(self.tag(f"Input ready ✓"))
+
+            # ── 4. تغيير النموذج ────────────────────────────────
+            await self._select_model(page, model_label)
+
+            # ── 5. إرسال ────────────────────────────────────────
+            await self._send(page, prompt)
+
+            # ── 6. استخراج الرد ─────────────────────────────────
+            return await self._extract(page)
+
+        except Exception as e:
+            print(self.tag(f"Error: {e}"))
+            raise RuntimeError(f"duck.ai error: {e}")
+        finally:
+            await page.close()
+
+    async def _select_model(self, page, model_label: str):
+        try:
+            btn  = page.locator('button[data-testid="model-select-button"]')
+            text = (await btn.inner_text()).strip()
+            print(self.tag(f"Current model: {text}"))
+            if model_label.lower() in text.lower():
+                return
+
+            await btn.click()
             await asyncio.sleep(2)
 
-            # البحث عن النموذج في القائمة
-            # من HTML: قائمة فيها اسم النموذج كنص
             option = page.locator(
                 f'li:has-text("{model_label}"), '
                 f'[role="option"]:has-text("{model_label}"), '
                 f'button:has-text("{model_label}")'
             )
-
             if await option.count() > 0:
                 await option.first.click()
-                print(f"[DUCK] Model selected: {model_label} ✓")
+                print(self.tag(f"Model → {model_label} ✓"))
                 await asyncio.sleep(1)
 
-                # البحث عن زر "Start chat" بعد اختيار النموذج
-                start_btn = page.locator(
-                    'button:has-text("Start chat"), '
-                    'button:has-text("Start new chat")'
+                start = page.locator(
+                    'button:has-text("Start chat"), button:has-text("Start new chat")'
                 )
-                if await start_btn.count() > 0:
-                    await start_btn.first.click()
-                    print("[DUCK] Start chat clicked ✓")
+                if await start.count() > 0:
+                    await start.first.click()
+                    print(self.tag("Start chat ✓"))
                     await asyncio.sleep(2)
 
-                # انتظر textarea بعد التغيير
                 await page.wait_for_selector(
-                    'textarea[name="user-prompt"]',
-                    state="visible",
-                    timeout=15000
+                    'textarea[name="user-prompt"]', state="visible", timeout=15000
                 )
-                print("[DUCK] Textarea ready after model change ✓")
-                return True
+                print(self.tag("Textarea ready ✓"))
             else:
                 await page.keyboard.press("Escape")
-                print(f"[DUCK] Model '{model_label}' not in list, using default")
-                return False
+                print(self.tag("Model not found, using default"))
 
         except Exception as e:
-            print(f"[DUCK] Model select error (non-fatal): {e}")
-            return False
-
-    async def _inject_and_send(self, page, prompt: str) -> bool:
-        """
-        حقن النص في textarea وإرساله
-        """
-        # حقن النص عبر JavaScript مع React events
+            print(self.tag(f"Model select (non-fatal): {e}"))
+
+    async def _send(self, page, prompt: str):
         await page.evaluate(
             """
             (text) => {
                 const ta = document.querySelector('textarea[name="user-prompt"]');
                 if (!ta) return;
-                const nativeSetter = Object.getOwnPropertyDescriptor(
+                const setter = Object.getOwnPropertyDescriptor(
                     window.HTMLTextAreaElement.prototype, 'value'
                 ).set;
-                nativeSetter.call(ta, text);
-                ta.dispatchEvent(new InputEvent('input',  { bubbles: true }));
+                setter.call(ta, text);
+                ta.dispatchEvent(new InputEvent('input', { bubbles: true }));
                 ta.dispatchEvent(new Event('change', { bubbles: true }));
                 ta.focus();
             }
@@ -180,180 +194,144 @@ class AsyncBrowserThread(threading.Thread):
         )
         await asyncio.sleep(2)
 
-        # محاولة 1: زر Submit
+        sent = False
         try:
-            send_btn = page.locator('button[type="submit"][aria-label="Send"]')
-            is_disabled = await send_btn.get_attribute("disabled")
-            if is_disabled is None:
-                await send_btn.click()
-                print(f"[DUCK] Sent via button ✓ ({len(prompt)} chars)")
-                return True
+            btn = page.locator('button[type="submit"][aria-label="Send"]')
+            if await btn.get_attribute("disabled") is None:
+                await btn.click()
+                sent = True
+                print(self.tag(f"Sent via button ✓ ({len(prompt)} chars)"))
         except Exception:
             pass
 
-        # محاولة 2: Enter على الـ textarea
-        try:
+        if not sent:
             ta = page.locator('textarea[name="user-prompt"]')
             await ta.click()
             await asyncio.sleep(0.3)
             await page.keyboard.press("Enter")
-            print(f"[DUCK] Sent via Enter ✓ ({len(prompt)} chars)")
-            return True
-        except Exception as e:
-            print(f"[DUCK] Send failed: {e}")
-            return False
-
-    async def _wait_for_response(self, page) -> str:
-        """
-        انتظار اكتمال الرد واستخراجه
-        """
-        # انتظر ظهور الرد
+            print(self.tag(f"Sent via Enter ✓"))
+
+    async def _extract(self, page) -> str:
         await asyncio.sleep(3)
 
-        # انتظر زر Copy بـ data-copyairesponse="true"
-        # هذا يظهر فقط بعد اكتمال الرد الأخير
+        # انتظر زر Copy — يظهر فقط بعد اكتمال الرد
         try:
-            copy_btn = page.locator('button[data-copyairesponse="true"]')
-            await copy_btn.last.wait_for(state="visible", timeout=90000)
-            print("[DUCK] Response complete (copy button appeared) ✓")
-            await asyncio.sleep(1)
+            copy = page.locator('button[data-copyairesponse="true"]')
+            await copy.last.wait_for(state="visible", timeout=90000)
+            print(self.tag("Response complete ✓"))
         except Exception:
-            print("[DUCK] Copy button not detected, using fallback wait...")
             # fallback: انتظر اختفاء Stop button
-            max_wait = 120
-            elapsed  = 0
-            while elapsed < max_wait:
+            for _ in range(75):
                 await asyncio.sleep(2)
-                elapsed += 2
-                stop_active = await page.locator(
+                if await page.locator(
                     'button[aria-label="Stop generating"]:not([disabled])'
-                ).count()
-                if stop_active == 0:
-                    print(f"[DUCK] Response complete (stop gone ~{elapsed}s) ✓")
+                ).count() == 0:
+                    print(self.tag("Response complete (fallback) ✓"))
                     break
 
         await asyncio.sleep(1)
 
-        # استخراج النص من البنية الحقيقية
-        # من HTML: div[data-activeresponse="true"] > ... > div.space-y-4
-        response_text = await page.evaluate("""
+        text = await page.evaluate("""
             () => {
-                // طريقة 1: div[data-activeresponse="true"] — البنية الحقيقية لـ duck.ai
-                const activeResp = document.querySelector('[data-activeresponse="true"]');
-                if (activeResp) {
-                    // النص في div.space-y-4 داخل الرد
-                    const textDiv = activeResp.querySelector('.space-y-4');
-                    if (textDiv && textDiv.innerText.trim().length > 0) {
-                        return textDiv.innerText.trim();
-                    }
-                    // أو النص المباشر
-                    const prose = activeResp.querySelector(
-                        '[class*="whitespace-normal"], [class*="prose"]'
-                    );
-                    if (prose && prose.innerText.trim().length > 0) {
-                        return prose.innerText.trim();
-                    }
+                const active = document.querySelector('[data-activeresponse="true"]');
+                if (active) {
+                    const sp = active.querySelector('.space-y-4');
+                    if (sp && sp.innerText.trim().length > 0) return sp.innerText.trim();
                 }
-
-                // طريقة 2: آخر div[data-activeresponse]
-                const allResps = document.querySelectorAll('[data-activeresponse]');
-                if (allResps.length > 0) {
-                    const last = allResps[allResps.length - 1];
-                    const textDiv = last.querySelector('.space-y-4');
-                    if (textDiv) return textDiv.innerText.trim();
+                const all = document.querySelectorAll('[data-activeresponse]');
+                if (all.length > 0) {
+                    const last = all[all.length - 1];
+                    const sp = last.querySelector('.space-y-4');
+                    if (sp) return sp.innerText.trim();
                     return last.innerText.trim();
                 }
-
-                // طريقة 3: article
-                const articles = document.querySelectorAll('article');
-                if (articles.length > 0) {
-                    return articles[articles.length - 1].innerText.trim();
+                const arts = document.querySelectorAll('article');
+                if (arts.length > 0) return arts[arts.length - 1].innerText.trim();
+                const divs = document.querySelectorAll('.space-y-4');
+                for (let i = divs.length - 1; i >= 0; i--) {
+                    if (divs[i].innerText.trim().length > 10) return divs[i].innerText.trim();
                 }
-
-                // طريقة 4: div.space-y-4 الأخير
-                const spaceDivs = document.querySelectorAll('.space-y-4');
-                if (spaceDivs.length > 0) {
-                    for (let i = spaceDivs.length - 1; i >= 0; i--) {
-                        const text = spaceDivs[i].innerText.trim();
-                        if (text.length > 10) return text;
-                    }
-                }
-
                 return '';
             }
         """)
 
-        return response_text.strip()
+        if not text or len(text.strip()) < 5:
+            await asyncio.sleep(5)
+            text = await page.evaluate("""
+                () => {
+                    const sp = document.querySelectorAll('.space-y-4');
+                    if (sp.length > 0) return sp[sp.length-1].innerText.trim();
+                    return document.body.innerText.slice(0, 5000);
+                }
+            """)
 
-    async def _chat(self, model_label: str, prompt: str) -> str:
-        page = await self.persistent_context.new_page()
-        try:
-            page.set_default_timeout(180000)
+        print(self.tag(f"Extracted {len(text)} chars ✓"))
+        return text.strip()
 
-            # ── 1. فتح الصفحة ──────────────────────────────────────
-            await page.goto(
-                "https://duckduckgo.com/aichat", wait_until="domcontentloaded"
-            )
-            await asyncio.sleep(3)
 
-            # ── 2. قبول Popup احتياطي ──────────────────────────────
-            try:
-                agree = page.locator('button:has-text("Agree and Continue")')
-                if await agree.count() > 0 and await agree.first.is_visible():
-                    await agree.first.click()
-                    print("[DUCK] Terms re-accepted ✓")
-                    await asyncio.sleep(2)
-            except Exception:
-                pass
+# ====================================================================
+# Browser Pool Manager
+# ====================================================================
 
-            # ── 3. انتظار textarea ─────────────────────────────────
-            await page.wait_for_selector('textarea[name="user-prompt"]')
-            print("[DUCK] Input ready ✓")
+class BrowserPool:
+    """
+    Pool من المتصفحات المتوازية.
+    POOL_SIZE = عدد الطلبات المتزامنة الممكنة.
+    """
 
-            # ── 4. تغيير النموذج ───────────────────────────────────
-            await self._select_model(page, model_label)
+    def __init__(self):
+        self.loop        = asyncio.new_event_loop()
+        self.workers: list[BrowserWorker] = []
+        self.ready_event = threading.Event()
+        self._thread     = threading.Thread(target=self._run, daemon=True)
+        self._queue: asyncio.Queue | None = None
 
-            # ── 5. إرسال الرسالة ───────────────────────────────────
-            sent = await self._inject_and_send(page, prompt)
-            if not sent:
-                raise RuntimeError("Failed to send message")
-
-            # ── 6. انتظار واستخراج الرد ────────────────────────────
-            response_text = await self._wait_for_response(page)
-
-            # fallback إذا كان فارغاً
-            if not response_text or len(response_text.strip()) < 5:
-                await asyncio.sleep(5)
-                response_text = await page.evaluate("""
-                    () => {
-                        const arts = document.querySelectorAll('article');
-                        if (arts.length > 0) return arts[arts.length-1].innerText.trim();
-                        const sp = document.querySelectorAll('.space-y-4');
-                        if (sp.length > 0) return sp[sp.length-1].innerText.trim();
-                        return document.body.innerText.slice(0, 5000);
-                    }
-                """)
-
-            print(f"[DUCK] Extracted {len(response_text)} chars ✓")
-            return response_text.strip()
+    def start(self):
+        self._thread.start()
+        print(f"[POOL] Starting {POOL_SIZE} browsers...")
 
-        except Exception as e:
-            print(f"[DUCK] Error: {e}")
-            raise RuntimeError(f"duck.ai error: {e}")
+    def _run(self):
+        asyncio.set_event_loop(self.loop)
+        self.loop.run_until_complete(self._init_pool())
+        self.ready_event.set()
+        print(f"[POOL] All {POOL_SIZE} browsers ready! ✓")
+        self.loop.run_forever()
+
+    async def _init_pool(self):
+        from playwright.async_api import async_playwright
+        self._queue = asyncio.Queue()
+        pw = await async_playwright().start()
+
+        # إنشاء كل المتصفحات بالتوازي
+        workers = [BrowserWorker(i + 1, self.loop) for i in range(POOL_SIZE)]
+        await asyncio.gather(*[w.init(pw) for w in workers])
+
+        self.workers = workers
+        for w in workers:
+            await self._queue.put(w)
+
+    async def _process(self, model_label: str, prompt: str) -> str:
+        # انتظر worker حر من الـ queue
+        worker: BrowserWorker = await self._queue.get()
+        print(f"[POOL] Assigned W{worker.id} ✓")
+        try:
+            result = await worker.chat(model_label, prompt)
+            return result
         finally:
-            await page.close()
+            await self._queue.put(worker)  # أعد الـ worker للـ pool
+            print(f"[POOL] W{worker.id} returned to pool ✓")
 
     def process(self, model_label: str, prompt: str) -> str:
-        if not self.ready_event.wait(timeout=120):
-            raise RuntimeError("Browser not ready")
+        if not self.ready_event.wait(timeout=180):
+            raise RuntimeError("Pool not ready")
         future = asyncio.run_coroutine_threadsafe(
-            self._chat(model_label, prompt), self.loop
+            self._process(model_label, prompt), self.loop
         )
-        return future.result(timeout=210)
+        return future.result(timeout=240)
 
 
-browser_engine = AsyncBrowserThread()
-browser_engine.start()
+pool = BrowserPool()
+pool.start()
 
 
 # ====================================================================
@@ -363,13 +341,11 @@ browser_engine.start()
 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 "\n".join(
+            item.get("text", item.get("content", str(item)))
+            if isinstance(item, dict) else str(item)
+            for item in content
+        )
     return str(content) if content else ""
 
 
@@ -381,9 +357,7 @@ def _build_prompt(messages: list) -> str:
         if not content.strip():
             continue
         if role == "system":
-            parts.append(
-                f"=== SYSTEM INSTRUCTIONS ===\n{content}\n=== END INSTRUCTIONS ==="
-            )
+            parts.append(f"=== SYSTEM INSTRUCTIONS ===\n{content}\n=== END INSTRUCTIONS ===")
         elif role == "assistant":
             parts.append(f"[Assistant]: {content}")
         else:
@@ -408,7 +382,7 @@ def _parse_tool_calls(text: str):
                 raw = parsed["tool_calls"]
                 if isinstance(raw, list) and raw:
                     return [{
-                        "id":   f"call_{uuid.uuid4().hex[:24]}",
+                        "id": f"call_{uuid.uuid4().hex[:24]}",
                         "type": "function",
                         "function": {
                             "name": call.get("name", ""),
@@ -485,7 +459,7 @@ async def chat_completions(request: Request):
     print(f"[API] /v1/chat/completions → {model} ({model_label})")
     try:
         text = await asyncio.get_event_loop().run_in_executor(
-            None, browser_engine.process, model_label, prompt
+            None, pool.process, model_label, prompt
         )
         return _make_completion(start_time, model, text, messages, tools)
     except Exception as e:
@@ -525,7 +499,7 @@ async def responses(request: Request):
     print(f"[API] /v1/responses → {model} ({model_label})")
     try:
         text = await asyncio.get_event_loop().run_in_executor(
-            None, browser_engine.process, model_label, prompt
+            None, pool.process, model_label, prompt
         )
         p  = sum(len(_extract_content(m).split()) for m in messages)
         c  = len(text.split())
@@ -565,10 +539,14 @@ async def list_models(request: Request):
 @app.get("/health")
 @app.get("/")
 async def health():
+    busy = sum(1 for w in pool.workers if w.busy)
     return {
-        "status":  "running",
-        "message": "Duck.ai API Server is active!",
-        "models":  ALL_MODELS,
+        "status":       "running",
+        "message":      "Duck.ai API Pool Server is active!",
+        "models":       ALL_MODELS,
+        "pool_size":    POOL_SIZE,
+        "workers_busy": busy,
+        "workers_free": POOL_SIZE - busy,
     }