Upload 4 files

Dockerfile

@@ -0,0 +1,41 @@
+FROM python:3.10-slim
+
+RUN useradd -m -u 1000 user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH \
+    PYTHONUNBUFFERED=1 \
+    PLAYWRIGHT_BROWSERS_PATH=/home/user/.cache/ms-playwright
+
+WORKDIR /home/user/app
+
+RUN apt-get update && apt-get install -y \
+    wget gnupg ca-certificates curl \
+    libnss3 libnspr4 libatk1.0-0 libatk-bridge2.0-0 \
+    libcups2 libdrm2 libxkbcommon0 libxcomposite1 \
+    libxdamage1 libxext6 libxfixes3 libxrandr2 libgbm1 \
+    libpango-1.0-0 libcairo2 libasound2 \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+RUN mkdir -p /etc/apt/keyrings \
+    && wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub \
+       | gpg --dearmor -o /etc/apt/keyrings/google-chrome.gpg \
+    && echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/google-chrome.gpg] \
+       http://dl.google.com/linux/chrome/deb/ stable main" \
+       > /etc/apt/sources.list.d/google-chrome.list \
+    && apt-get update && apt-get install -y google-chrome-stable \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN playwright install chromium
+
+COPY --chown=user . .
+
+USER user
+EXPOSE 7860
+
+HEALTHCHECK --interval=30s --timeout=15s --start-period=120s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,10 @@
 ---
-title: Dz
-emoji: 🏆
-colorFrom: green
+title: DZ Serve
+emoji: 🤖
+colorFrom: blue
 colorTo: purple
 sdk: docker
+app_port: 7860
 pinned: false
+license: mit
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

main.py

@@ -0,0 +1,621 @@
+import os
+import uuid
+import time
+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
+
+# ====================================================================
+# Configuration
+# ====================================================================
+API_SECRET_KEY = os.getenv("API_SECRET_KEY", "change-me-secret")
+
+# ── Duck.ai models (HTTP مباشر - بدون Playwright) ──────────────────
+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",
+}
+
+# ── ZAI models (Playwright - browser scraping) ─────────────────────
+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
+
+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)
+# ====================================================================
+
+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
+
+    def run(self):
+        asyncio.set_event_loop(self.loop)
+        self.loop.run_until_complete(self._start_browser())
+        self.ready_event.set()
+        print("[ZAI-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...")
+        self.playwright = await async_playwright().start()
+        self.browser = await self.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",
+            ],
+        )
+        print("[ZAI-SERVER] Chrome launched!")
+
+    async def _talk_to_zai(self, prompt: 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-SERVER] 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-SERVER] Response: {len(last_text)} chars")
+            return last_text.strip()
+        except Exception as e:
+            print(f"[ZAI-SERVER] Error: {e}")
+            raise e
+        finally:
+            await page.close()
+            await context.close()
+
+    def process_request(self, prompt: 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)
+        return future.result(timeout=120)
+
+
+browser_engine = AsyncBrowserThread()
+browser_engine.start()
+
+
+# ====================================================================
+# Prompt Builder (للـ ZAI models - محفوظ بالكامل)
+# ====================================================================
+
+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  = 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)
+
+        if role == "system":
+            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}")
+        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}")
+        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}]")
+        elif role == "assistant":
+            assistant_content  = content if content else ""
+            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}")
+        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 ===\nThe following information was retrieved by the tools you requested.\nUse ONLY this information to answer the user's question.\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"
+
+    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"
+
+    for tool in tools:
+        func   = tool.get("function", tool)
+        name   = func.get("name", "unknown")
+        desc   = func.get("description", "No description")
+        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
+
+
+def parse_tool_calls(response_text):
+    cleaned = response_text.strip()
+    if "```" in cleaned:
+        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)
+            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
+        except (json.JSONDecodeError, TypeError, KeyError):
+            continue
+    return None
+
+
+# ====================================================================
+# Helpers
+# ====================================================================
+
+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):
+    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:
+        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": tool_calls}, "finish_reason": "tool_calls"}],
+            "usage":   {"prompt_tokens": p_tokens, "completion_tokens": c_tokens,
+                        "total_tokens": p_tokens + c_tokens},
+        }
+    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},
+                     "finish_reason": "stop"}],
+        "usage":   {"prompt_tokens": p_tokens, "completion_tokens": c_tokens,
+                    "total_tokens": p_tokens + c_tokens},
+    }
+
+
+# ====================================================================
+# FastAPI App
+# ====================================================================
+app = FastAPI(title="ZAI + DuckAI API Server")
+
+
+# ── POST /v1/chat/completions ──────────────────────────────────────
+@app.post("/v1/chat/completions")
+async def chat_completions(request: Request):
+    try:
+        data = await request.json()
+    except Exception:
+        return JSONResponse(status_code=400, content={"error": {"message": "Invalid JSON payload"}})
+
+    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"}})
+
+    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 ─────────────────────────────────
+        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)
+
+    except Exception as e:
+        return JSONResponse(status_code=500, content={"error": {"message": str(e)}})
+
+
+# ── POST /v1/responses ────────────────────────────────────────────
+@app.post("/v1/responses")
+async def responses(request: Request):
+    try:
+        data = await request.json()
+    except Exception:
+        return JSONResponse(status_code=400, content={"error": {"message": "Invalid JSON payload"}})
+
+    if not _auth(request):
+        return JSONResponse(status_code=401, content={"error": {"message": "Invalid API Key"}})
+
+    input_data = data.get("input", "")
+    if isinstance(input_data, str):
+        messages = [{"role": "user", "content": input_data}]
+    elif isinstance(input_data, list):
+        messages = input_data
+    else:
+        messages = data.get("messages", [])
+
+    if not messages:
+        return JSONResponse(status_code=400, content={"error": {"message": "input field is required"}})
+
+    model        = data.get("model", "gpt-4o-mini")
+    tools        = data.get("tools", None)
+    instructions = data.get("instructions", "")
+    if instructions:
+        messages.insert(0, {"role": "system", "content": instructions})
+
+    start_time = time.time()
+
+    try:
+        if _is_duck_model(model):
+            response_text = await duck_chat_complete(model, messages)
+        else:
+            prompt        = format_prompt(messages, tools=tools)
+            response_text = browser_engine.process_request(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",
+                })
+            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},
+            }
+
+        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},
+        }
+
+    except Exception as e:
+        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):
+        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
+        ],
+    }
+
+
+# ── GET /health  &  GET / ─────────────────────────────────────────
+@app.get("/health")
+@app.get("/")
+async def health_check():
+    return {
+        "status":      "running",
+        "message":     "ZAI + DuckAI API Server is active!",
+        "duck_models": list(DUCK_MODELS.keys()),
+        "zai_models":  ZAI_MODELS,
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.110.0
+uvicorn==0.27.1
+playwright==1.42.0
+pydantic==2.6.3
+python-multipart==0.0.9
+httpx==0.27.0