refactor: use DS2API proxy for reliable backend

- Add proxy.py to forward requests to original DS2API
- Keep all API endpoints (OpenAI, Claude, Gemini, Ollama)
- Add account mute detection
- Fix streaming by creating client inside generator

account_manager.py

@@ -1,10 +1,9 @@
 import asyncio
-import random
 from collections import deque
 from dataclasses import dataclass, field
 from typing import Dict, Optional
 
-from deepseek_browser import DeepSeekBrowser
+from deepseek_api import DeepSeekAPI
 
 
 @dataclass
@@ -13,9 +12,9 @@ class Account:
     password: str
     name: str = ""
     proxy: Optional[str] = None
-    browser: Optional[DeepSeekBrowser] = field(default=None, repr=False)
-    in_use_count: int = 0  # 当前并发数
-    max_concurrent: int = 3  # 最大并发数
+    api: Optional[DeepSeekAPI] = field(default=None, repr=False)
+    in_use_count: int = 0
+    max_concurrent: int = 3
     error_count: int = 0
     logged_in: bool = False
 
@@ -38,13 +37,11 @@ class AccountManager:
 
     async def acquire(self) -> Account:
         async with self._lock:
-            # 找一个可用的账号（并发数未满）
             for account in self.accounts.values():
                 if account.in_use_count < account.max_concurrent and account.error_count < 3:
                     account.in_use_count += 1
                     return account
 
-        # 没有可用账号，等待
         return await self._wait_for_account()
 
     async def _wait_for_account(self) -> Account:
@@ -77,39 +74,36 @@ class AccountManager:
                 event = self.queue.popleft()
                 event.set()
 
-    async def get_or_create_browser(self, account: Account, headless: bool = True) -> DeepSeekBrowser:
+    async def get_api(self, account: Account) -> DeepSeekAPI:
         try:
-            if account.browser is None:
-                account.browser = DeepSeekBrowser(
+            if account.api is None:
+                account.api = DeepSeekAPI(
                     email=account.email,
                     password=account.password,
-                    profile_dir="./profiles",
-                    headless=headless,
-                    humanize=True,
                     proxy=account.proxy,
                 )
-                await account.browser.start()
+                await account.api.login()
                 account.logged_in = True
-            return account.browser
+            return account.api
         except Exception as e:
-            print(f"Error creating browser: {e}")
-            await self.close_browser(account)
+            print(f"Error creating API: {e}")
+            await self.close_api(account)
             raise
 
-    async def get_or_create_browser_with_retry(self, account: Account, headless: bool = True) -> DeepSeekBrowser:
+    async def get_api_with_retry(self, account: Account) -> DeepSeekAPI:
         try:
-            return await self.get_or_create_browser(account, headless)
+            return await self.get_api(account)
         except Exception:
-            await self.close_browser(account)
-            return await self.get_or_create_browser(account, headless)
+            await self.close_api(account)
+            return await self.get_api(account)
 
-    async def close_browser(self, account: Account):
-        if account.browser:
+    async def close_api(self, account: Account):
+        if account.api:
             try:
-                await account.browser.close()
+                await account.api.close()
             except:
                 pass
-            account.browser = None
+            account.api = None
             account.logged_in = False
 
     def get_stats(self) -> Dict:

deepseek_api.py

@@ -0,0 +1,261 @@
+import asyncio
+import hashlib
+import json
+import random
+import time
+import uuid
+from typing import AsyncGenerator, Optional
+
+import httpx
+
+
+class DeepSeekAPI:
+    LOGIN_URL = "https://chat.deepseek.com/api/v0/users/login"
+    CREATE_SESSION_URL = "https://chat.deepseek.com/api/v0/chat_session/create"
+    CREATE_POW_URL = "https://chat.deepseek.com/api/v0/chat/create_pow_challenge"
+    COMPLETION_URL = "https://chat.deepseek.com/api/v0/chat/completion"
+    DELETE_SESSION_URL = "https://chat.deepseek.com/api/v0/chat_session/delete"
+
+    def __init__(self, email: str, password: str, proxy: Optional[str] = None):
+        self.email = email
+        self.password = password
+        self.proxy = proxy
+        self._token: Optional[str] = None
+        self._device_id = str(uuid.uuid4())
+        self._client: Optional[httpx.AsyncClient] = None
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None or self._client.is_closed:
+            self._client = httpx.AsyncClient(
+                proxy=self.proxy,
+                timeout=60.0,
+                follow_redirects=True,
+            )
+        return self._client
+
+    async def login(self) -> str:
+        client = await self._get_client()
+        
+        payload = {
+            "email": self.email,
+            "password": self.password,
+            "device_id": self._device_id,
+            "os": "android",
+        }
+        
+        headers = self._base_headers()
+        
+        resp = await client.post(self.LOGIN_URL, json=payload, headers=headers, timeout=30)
+        data = resp.json()
+        
+        code = data.get("code", -1)
+        if code != 0:
+            raise Exception(f"Login failed: {data.get('msg', 'Unknown')}")
+        
+        biz_data = data.get("data", {})
+        biz_code = biz_data.get("biz_code", -1)
+        if biz_code != 0:
+            raise Exception(f"Login failed: {biz_data.get('biz_msg', 'Unknown')}")
+        
+        user = biz_data.get("biz_data", {}).get("user", {})
+        self._token = user.get("token", "")
+        
+        if not self._token:
+            raise Exception("No token received")
+        
+        return self._token
+
+    async def create_session(self) -> str:
+        if not self._token:
+            await self.login()
+        
+        client = await self._get_client()
+        headers = self._auth_headers()
+        
+        resp = await client.post(
+            self.CREATE_SESSION_URL,
+            json={"agent": "chat"},
+            headers=headers,
+            timeout=30,
+        )
+        data = resp.json()
+        
+        if data.get("code") != 0:
+            raise Exception(f"Create session failed: {data.get('msg')}")
+        
+        biz_data = data.get("data", {}).get("biz_data", {})
+        
+        if "chat_session" in biz_data:
+            session_id = biz_data["chat_session"].get("id", "")
+        else:
+            session_id = biz_data.get("id", "")
+        
+        if not session_id:
+            raise Exception("No session ID received")
+        
+        return session_id
+
+    async def get_pow(self, target_path: str = "/api/v0/chat/completion") -> dict:
+        client = await self._get_client()
+        headers = self._auth_headers()
+        
+        resp = await client.post(
+            self.CREATE_POW_URL,
+            json={"target_path": target_path},
+            headers=headers,
+            timeout=30,
+        )
+        data = resp.json()
+        
+        if data.get("code") != 0:
+            raise Exception(f"Get PoW failed: {data.get('msg')}")
+        
+        return data.get("data", {}).get("biz_data", {}).get("challenge", {})
+
+    def _compute_pow(self, challenge: dict) -> str:
+        prefix = challenge.get("prefix", "")
+        target = challenge.get("target", "")
+        expire_at = challenge.get("expire_at", 0)
+        
+        nonce = 0
+        while nonce < 10000000:
+            test = f"{prefix}{nonce}"
+            hash_val = hashlib.sha256(test.encode()).hexdigest()
+            if hash_val.startswith("0" * len(target)):
+                break
+            nonce += 1
+        
+        return json.dumps({
+            "prefix": prefix,
+            "nonce": nonce,
+            "expire_at": expire_at,
+            "target": target,
+        })
+
+    async def send_message(
+        self,
+        prompt: str,
+        model: str = "deepseek-chat",
+        stream: bool = False,
+        timeout: int = 120,
+    ) -> str:
+        if not self._token:
+            await self.login()
+        
+        session_id = await self.create_session()
+        
+        pow_challenge = await self.get_pow()
+        pow_header = self._compute_pow(pow_challenge)
+        
+        client = await self._get_client()
+        headers = self._auth_headers()
+        headers["x-ds-pow-response"] = pow_header
+        
+        payload = {
+            "chat_session_id": session_id,
+            "parent_message_id": None,
+            "prompt": prompt,
+            "ref_file_ids": [],
+            "thinking_enabled": True,
+            "search_enabled": "search" in model.lower(),
+        }
+        
+        if stream:
+            return self._stream_completion(client, headers, payload, timeout)
+        else:
+            return await self._sync_completion(client, headers, payload, timeout)
+
+    async def _sync_completion(
+        self,
+        client: httpx.AsyncClient,
+        headers: dict,
+        payload: dict,
+        timeout: int,
+    ) -> str:
+        resp = await client.post(
+            self.COMPLETION_URL,
+            json=payload,
+            headers=headers,
+            timeout=timeout,
+        )
+        
+        # 处理 SSE 响应
+        full_text = ""
+        for line in resp.text.split("\n"):
+            if line.startswith("data:"):
+                data_str = line[5:].strip()
+                if data_str == "[DONE]":
+                    continue
+                try:
+                    data = json.loads(data_str)
+                    msg = data.get("message", {})
+                    content = msg.get("content", "")
+                    if content:
+                        full_text += content
+                except json.JSONDecodeError:
+                    continue
+        
+        return full_text
+
+    async def _stream_completion(
+        self,
+        client: httpx.AsyncClient,
+        headers: dict,
+        payload: dict,
+        timeout: int,
+    ) -> AsyncGenerator[str, None]:
+        async with client.stream(
+            "POST",
+            self.COMPLETION_URL,
+            json=payload,
+            headers=headers,
+            timeout=timeout,
+        ) as resp:
+            async for line in resp.aiter_lines():
+                if line.startswith("data:"):
+                    data_str = line[5:].strip()
+                    if data_str == "[DONE]":
+                        return
+                    try:
+                        data = json.loads(data_str)
+                        msg = data.get("message", {})
+                        content = msg.get("content", "")
+                        if content:
+                            yield content
+                    except json.JSONDecodeError:
+                        continue
+
+    async def delete_session(self, session_id: str):
+        if not self._token:
+            return
+        
+        client = await self._get_client()
+        headers = self._auth_headers()
+        
+        await client.post(
+            self.DELETE_SESSION_URL,
+            json={"chat_session_id": session_id},
+            headers=headers,
+            timeout=30,
+        )
+
+    def _base_headers(self) -> dict:
+        return {
+            "Content-Type": "application/json",
+            "User-Agent": "DeepSeek/3.2.1 Android/35",
+            "x-client-platform": "android",
+            "x-client-version": "3.2.1",
+            "x-client-locale": "zh_CN",
+            "Accept-Encoding": "gzip, deflate, br",
+            "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
+        }
+
+    def _auth_headers(self) -> dict:
+        headers = self._base_headers()
+        if self._token:
+            headers["authorization"] = f"Bearer {self._token}"
+        return headers
+
+    async def close(self):
+        if self._client:
+            await self._client.aclose()

deepseek_browser.py

@@ -1,14 +1,19 @@
 import asyncio
 import random
 import time
+import uuid
 from pathlib import Path
 from typing import AsyncGenerator, Optional
 
+import httpx
 from cloakbrowser import launch_persistent_context_async
 
 
 class DeepSeekBrowser:
     DEEPSEEK_URL = "https://chat.deepseek.com"
+    LOGIN_URL = "https://chat.deepseek.com/api/v0/users/login"
+    CREATE_SESSION_URL = "https://chat.deepseek.com/api/v0/chat_session/create"
+    COMPLETION_URL = "https://chat.deepseek.com/api/v0/chat/completion"
 
     def __init__(
         self,
@@ -29,10 +34,15 @@ class DeepSeekBrowser:
         self.page = None
         self._logged_in = False
         self._ready = False
+        self._token = None
+        self._session_id = None
 
     async def start(self):
         self.profile_dir.mkdir(parents=True, exist_ok=True)
 
+        # 先用 API 登录获取 token
+        await self._login_via_api()
+
         self.context = await launch_persistent_context_async(
             user_data_dir=str(self.profile_dir),
             headless=self.headless,
@@ -43,60 +53,67 @@ class DeepSeekBrowser:
         )
 
         self.page = await self.context.new_page()
-        await self.page.goto(self.DEEPSEEK_URL, timeout=60000)
-        await asyncio.sleep(5)
-
-        await self._check_login_state()
+        
+        # 设置 token cookie
+        if self._token:
+            await self.context.add_cookies([{
+                "name": "token",
+                "value": self._token,
+                "domain": ".deepseek.com",
+                "path": "/",
+            }])
 
-    async def _check_login_state(self):
-        current_url = self.page.url
-
-        if '/sign_in' in current_url:
-            await self._auto_login()
-        else:
-            try:
-                await self.page.wait_for_selector('textarea', timeout=10000)
-                self._logged_in = True
-                self._ready = True
-            except Exception:
-                await self._auto_login()
-
-    async def _auto_login(self):
-        print(f"Logging in as {self.email}...")
-
-        try:
-            email_input = self.page.locator('input[placeholder*="邮箱"], input[placeholder*="手机"], input[type="text"]').first
-            await email_input.wait_for(state="visible", timeout=10000)
-            await email_input.fill(self.email)
-            await asyncio.sleep(0.5)
-        except Exception as e:
-            print(f"Email input error: {e}")
-            raise
-
-        try:
-            password_input = self.page.locator('input[type="password"]').first
-            await password_input.wait_for(state="visible", timeout=5000)
-            await password_input.fill(self.password)
-            await asyncio.sleep(0.5)
-        except Exception as e:
-            print(f"Password input error: {e}")
-            raise
+        await self.page.goto(self.DEEPSEEK_URL, timeout=60000)
+        await asyncio.sleep(3)
 
-        try:
-            login_button = self.page.locator('button:has-text("登录")').first
-            await login_button.click()
+        # 检查是否登录成功
+        if '/sign_in' in self.page.url:
+            # 如果 cookie 方式失败，尝试通过 JS 注入 token
+            await self.page.evaluate(f"localStorage.setItem('token', '{self._token}')")
+            await self.page.reload()
             await asyncio.sleep(3)
-        except Exception as e:
-            print(f"Login button error: {e}")
-            raise
 
-        try:
-            await self.page.wait_for_selector('textarea', timeout=30000)
+        if '/sign_in' not in self.page.url:
             self._logged_in = True
             self._ready = True
-            print("Login successful!")
-        except Exception:
-            raise Exception("Login failed")
+        else:
+            raise Exception("Login failed - still on sign_in page")
+
+    async def _login_via_api(self):
+        """通过 DeepSeek API 登录获取 token"""
+        async with httpx.AsyncClient() as client:
+            device_id = str(uuid.uuid4())
+            payload = {
+                "email": self.email,
+                "password": self.password,
+                "device_id": device_id,
+                "os": "android",
+            }
+            
+            headers = {
+                "Content-Type": "application/json",
+                "User-Agent": "DeepSeek-Android/2.0",
+            }
+            
+            resp = await client.post(self.LOGIN_URL, json=payload, headers=headers, timeout=30)
+            data = resp.json()
+            
+            code = data.get("code", -1)
+            if code != 0:
+                msg = data.get("msg", "Unknown error")
+                raise Exception(f"API login failed: {msg}")
+            
+            biz_data = data.get("data", {})
+            biz_code = biz_data.get("biz_code", -1)
+            if biz_code != 0:
+                biz_msg = biz_data.get("biz_msg", "Unknown error")
+                raise Exception(f"API login failed: {biz_msg}")
+            
+            user = biz_data.get("biz_data", {}).get("user", {})
+            self._token = user.get("token", "")
+            
+            if not self._token:
+                raise Exception("No token received from API")
 
     async def _human_delay(self, min_ms: int = 300, max_ms: int = 1500):
         delay = random.uniform(min_ms, max_ms) / 1000
@@ -180,35 +197,37 @@ class DeepSeekBrowser:
         last_text = ""
         stable_count = 0
 
-        skip_phrases = ['深度思考', '智能搜索', '快速模式', '专家模式', '内容由 AI 生成', '开启新对话', '暂无历史对话', '今天', 'huan********dja@gmail.com']
+        skip_phrases = ['深度思考', '智能搜索', '快速模式', '专家模式', '内容由 AI 生成', '开启新对话', '暂无历史对话']
 
         while time.time() < deadline:
             try:
-                text = await self.page.inner_text('body')
-
-                lines = text.split('\n')
-                response_started = False
-                response_text = []
+                try:
+                    response_elements = await self.page.query_selector_all('.ds-markdown--block')
+                    if response_elements:
+                        last_response = response_elements[-1]
+                        current_text = await last_response.inner_text()
+                        current_text = current_text.strip()
+                    else:
+                        main_content = await self.page.query_selector('main, .chat-container, [class*="chat"]')
+                        if main_content:
+                            current_text = await main_content.inner_text()
+                        else:
+                            current_text = await self.page.inner_text('body')
+                except Exception:
+                    current_text = await self.page.inner_text('body')
 
+                lines = current_text.split('\n')
+                filtered_lines = []
                 for line in lines:
                     line = line.strip()
                     if not line:
                         continue
-
-                    if line == '内容由 AI 生成，请仔细甄别':
-                        break
-
                     if any(phrase in line for phrase in skip_phrases):
                         continue
+                    filtered_lines.append(line)
 
-                    if response_started:
-                        response_text.append(line)
-
-                    if prompt and prompt in line:
-                        response_started = True
-
-                if response_text:
-                    current_text = '\n'.join(response_text)
+                if filtered_lines:
+                    current_text = '\n'.join(filtered_lines)
 
                     if current_text != last_text:
                         last_text = current_text
@@ -250,37 +269,39 @@ class DeepSeekBrowser:
             last_text = ""
             stable_count = 0
 
-            skip_phrases = ['深度思考', '智能搜索', '快速模式', '专家模式', '内容由 AI 生成', '开启新对话', '暂无历史对话', '今天', 'huan********dja@gmail.com']
+            skip_phrases = ['深度思考', '智能搜索', '快速模式', '专家模式', '内容由 AI 生成', '开启新对话', '暂无历史对话']
 
             await asyncio.sleep(3)
 
             while time.time() < deadline:
                 try:
-                    text = await self.page.inner_text('body')
-
-                    lines = text.split('\n')
-                    response_started = False
-                    response_text = []
-
+                    try:
+                        response_elements = await self.page.query_selector_all('.ds-markdown--block')
+                        if response_elements:
+                            last_response = response_elements[-1]
+                            current_text = await last_response.inner_text()
+                            current_text = current_text.strip()
+                        else:
+                            main_content = await self.page.query_selector('main, .chat-container, [class*="chat"]')
+                            if main_content:
+                                current_text = await main_content.inner_text()
+                            else:
+                                current_text = await self.page.inner_text('body')
+                    except Exception:
+                        current_text = await self.page.inner_text('body')
+
+                    lines = current_text.split('\n')
+                    filtered_lines = []
                     for line in lines:
                         line = line.strip()
                         if not line:
                             continue
-
-                        if line == '内容由 AI 生成，请仔细甄别':
-                            break
-
                         if any(phrase in line for phrase in skip_phrases):
                             continue
+                        filtered_lines.append(line)
 
-                        if response_started:
-                            response_text.append(line)
-
-                        if prompt and prompt in line:
-                            response_started = True
-
-                    if response_text:
-                        current_text = '\n'.join(response_text)
+                    if filtered_lines:
+                        current_text = '\n'.join(filtered_lines)
 
                         if current_text != last_text:
                             new_chunk = current_text[len(last_text):]

main.py

@@ -105,13 +105,13 @@ async def chat_completions(
     account = await manager.acquire()
 
     try:
-        browser = await manager.get_or_create_browser_with_retry(account, headless=config.browser.headless)
+        api = await manager.get_api_with_retry(account)
 
         if request.stream:
             async def stream_with_cleanup():
                 chunk_id = f"chatcmpl-{uuid.uuid4().hex[:8]}"
                 try:
-                    async for chunk in browser.stream_message(prompt, timeout=120, model=request.model):
+                    async for chunk in api.send_message(prompt, model=request.model, stream=True, timeout=120):
                         data = {
                             "id": chunk_id,
                             "object": "chat.completion.chunk",
@@ -152,7 +152,7 @@ async def chat_completions(
                 media_type="text/event-stream",
             )
 
-        response_text = await browser.send_message(prompt, timeout=120, model=request.model)
+        response_text = await api.send_message(prompt, model=request.model, stream=False, timeout=120)
 
         await manager.release(account)
 
@@ -211,12 +211,12 @@ async def anthropic_messages(request: Request, authorization: str = Header(...))
     account = await manager.acquire()
 
     try:
-        browser = await manager.get_or_create_browser_with_retry(account, headless=config.browser.headless)
+        api = await manager.get_api_with_retry(account)
 
         if stream:
             async def stream_with_cleanup():
                 try:
-                    async for chunk in browser.stream_message(prompt, timeout=120, model=model):
+                    async for chunk in api.send_message(prompt, model=model, stream=True, timeout=120):
                         data = {
                             "type": "content_block_delta",
                             "index": 0,
@@ -235,7 +235,7 @@ async def anthropic_messages(request: Request, authorization: str = Header(...))
                 media_type="text/event-stream",
             )
 
-        response_text = await browser.send_message(prompt, timeout=120, model=model)
+        response_text = await api.send_message(prompt, model=model, stream=False, timeout=120)
 
         await manager.release(account)
 
@@ -272,9 +272,9 @@ async def gemini_generate(model: str, request: Request, authorization: str = Hea
     account = await manager.acquire()
 
     try:
-        browser = await manager.get_or_create_browser_with_retry(account, headless=config.browser.headless)
+        api = await manager.get_api_with_retry(account)
 
-        response_text = await browser.send_message(prompt, timeout=120, model=model)
+        response_text = await api.send_message(prompt, model=model, stream=False, timeout=120)
 
         await manager.release(account)
 
@@ -315,11 +315,11 @@ async def gemini_stream_generate(model: str, request: Request, authorization: st
     account = await manager.acquire()
 
     try:
-        browser = await manager.get_or_create_browser_with_retry(account, headless=config.browser.headless)
+        api = await manager.get_api_with_retry(account)
 
         async def stream_with_cleanup():
             try:
-                async for chunk in browser.stream_message(prompt, timeout=120, model=model):
+                async for chunk in api.send_message(prompt, model=model, stream=True, timeout=120):
                     data = {
                         "candidates": [
                             {
@@ -442,12 +442,39 @@ async def list_accounts(admin_key: str = Header(...)):
         accounts.append({
             "email": email,
             "name": acc.name,
-            "in_use": acc.in_use,
+            "proxy": acc.proxy,
+            "in_use_count": acc.in_use_count,
+            "max_concurrent": acc.max_concurrent,
             "logged_in": acc.logged_in,
             "error_count": acc.error_count,
         })
 
-    return {"accounts": accounts, "total": len(accounts)}
+    return {
+        "accounts": accounts,
+        "total": len(accounts),
+        "max_concurrent_per_account": config.browser.max_concurrent_per_account,
+        "default_proxy": config.default_proxy,
+    }
+
+
+@app.get("/admin/config")
+async def get_config(admin_key: str = Header(...)):
+    if admin_key != config.server.admin_key:
+        raise HTTPException(status_code=401, detail="Invalid admin key")
+
+    return {
+        "server": {
+            "host": config.server.host,
+            "port": config.server.port,
+        },
+        "browser": {
+            "headless": config.browser.headless,
+            "max_concurrent_per_account": config.browser.max_concurrent_per_account,
+            "timeout": config.browser.timeout,
+        },
+        "default_proxy": config.default_proxy,
+        "account_count": len(manager.accounts),
+    }
 
 
 @app.on_event("startup")

proxy.py

@@ -0,0 +1,339 @@
+import json
+import time
+import uuid
+from typing import Optional
+
+import httpx
+from fastapi import FastAPI, HTTPException, Header, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+
+app = FastAPI(title="DS2API Browser Proxy")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+DS2API_URL = "http://127.0.0.1:5001"
+API_KEYS = ["sk-default", "sk-test123456"]
+ADMIN_KEY = "admin"
+
+
+class Message(BaseModel):
+    role: str
+    content: str
+
+
+class ChatCompletionRequest(BaseModel):
+    model: str
+    messages: list[Message]
+    stream: bool = False
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+
+
+def verify_api_key(authorization: Optional[str] = Header(None)) -> str:
+    if not authorization:
+        raise HTTPException(status_code=401, detail="Missing API key")
+
+    token = authorization.replace("Bearer ", "").strip()
+    if token not in API_KEYS:
+        raise HTTPException(status_code=401, detail="Invalid API key")
+
+    return token
+
+
+@app.get("/v1/models")
+async def list_models(authorization: str = Header(...)):
+    verify_api_key(authorization)
+    
+    async with httpx.AsyncClient() as client:
+        resp = await client.get(f"{DS2API_URL}/v1/models", headers={"Authorization": f"Bearer sk-test123456"})
+        return resp.json()
+
+
+@app.get("/v1/models/{model_id}")
+async def get_model(model_id: str, authorization: str = Header(...)):
+    verify_api_key(authorization)
+    
+    async with httpx.AsyncClient() as client:
+        resp = await client.get(f"{DS2API_URL}/v1/models/{model_id}", headers={"Authorization": f"Bearer sk-test123456"})
+        return resp.json()
+
+
+@app.post("/v1/chat/completions")
+async def chat_completions(
+    request: ChatCompletionRequest,
+    authorization: str = Header(...),
+):
+    verify_api_key(authorization)
+
+    if not request.messages:
+        raise HTTPException(status_code=400, detail="No messages provided")
+
+    async with httpx.AsyncClient() as client:
+        if request.stream:
+            async def stream_with_cleanup():
+                async with httpx.AsyncClient() as stream_client:
+                    async with stream_client.stream(
+                        "POST",
+                        f"{DS2API_URL}/v1/chat/completions",
+                        json=request.model_dump(),
+                        headers={"Authorization": "Bearer sk-test123456"},
+                        timeout=120,
+                    ) as resp:
+                        async for line in resp.aiter_lines():
+                            yield line + "\n"
+
+            return StreamingResponse(
+                stream_with_cleanup(),
+                media_type="text/event-stream",
+            )
+
+        resp = await client.post(
+            f"{DS2API_URL}/v1/chat/completions",
+            json=request.model_dump(),
+            headers={"Authorization": "Bearer sk-test123456"},
+            timeout=120,
+        )
+        return resp.json()
+
+
+@app.get("/anthropic/v1/models")
+async def anthropic_models(authorization: str = Header(...)):
+    verify_api_key(authorization)
+
+    return {
+        "data": [
+            {"id": "claude-sonnet-4-6", "object": "model", "created": int(time.time()), "owned_by": "anthropic"},
+            {"id": "claude-opus-4-6", "object": "model", "created": int(time.time()), "owned_by": "anthropic"},
+            {"id": "claude-haiku-4-5", "object": "model", "created": int(time.time()), "owned_by": "anthropic"},
+        ],
+        "object": "list",
+    }
+
+
+@app.post("/anthropic/v1/messages")
+async def anthropic_messages(request: Request, authorization: str = Header(...)):
+    verify_api_key(authorization)
+
+    body = await request.json()
+    messages = body.get("messages", [])
+    model = body.get("model", "claude-sonnet-4-6")
+    stream = body.get("stream", False)
+
+    if not messages:
+        raise HTTPException(status_code=400, detail="No messages provided")
+
+    prompt = messages[-1].get("content", "")
+
+    async with httpx.AsyncClient() as client:
+        if stream:
+            async def stream_with_cleanup():
+                async with httpx.AsyncClient() as stream_client:
+                    async with stream_client.stream(
+                        "POST",
+                        f"{DS2API_URL}/v1/chat/completions",
+                        json={"model": "deepseek-v4-flash", "messages": [{"role": "user", "content": prompt}], "stream": True},
+                        headers={"Authorization": "Bearer sk-test123456"},
+                        timeout=120,
+                    ) as resp:
+                        async for line in resp.aiter_lines():
+                            if line.startswith("data: "):
+                                data_str = line[6:].strip()
+                                if data_str == "[DONE]":
+                                    continue
+                                try:
+                                    data = json.loads(data_str)
+                                    content = data.get("choices", [{}])[0].get("delta", {}).get("content", "")
+                                    if content:
+                                        yield f"event: content_block_delta\ndata: {json.dumps({'type': 'content_block_delta', 'index': 0, 'delta': {'type': 'text_delta', 'text': content}})}\n\n"
+                                except json.JSONDecodeError:
+                                    pass
+                    
+                    yield f"event: message_stop\ndata: {json.dumps({'type': 'message_stop'})}\n\n"
+
+            return StreamingResponse(
+                stream_with_cleanup(),
+                media_type="text/event-stream",
+            )
+
+        resp = await client.post(
+            f"{DS2API_URL}/v1/chat/completions",
+            json={"model": "deepseek-v4-flash", "messages": [{"role": "user", "content": prompt}], "stream": False},
+            headers={"Authorization": "Bearer sk-test123456"},
+            timeout=120,
+        )
+        data = resp.json()
+        content = data.get("choices", [{}])[0].get("message", {}).get("content", "")
+
+        return {
+            "id": f"msg_{uuid.uuid4().hex[:8]}",
+            "type": "message",
+            "role": "assistant",
+            "model": model,
+            "content": [{"type": "text", "text": content}],
+            "stop_reason": "end_turn",
+            "usage": {
+                "input_tokens": len(prompt.split()),
+                "output_tokens": len(content.split()),
+            },
+        }
+
+
+@app.post("/v1beta/models/{model}:generateContent")
+async def gemini_generate(model: str, request: Request, authorization: str = Header(...)):
+    verify_api_key(authorization)
+
+    body = await request.json()
+    contents = body.get("contents", [])
+
+    if not contents:
+        raise HTTPException(status_code=400, detail="No contents provided")
+
+    prompt = contents[-1].get("parts", [{}])[0].get("text", "")
+
+    async with httpx.AsyncClient() as client:
+        resp = await client.post(
+            f"{DS2API_URL}/v1/chat/completions",
+            json={"model": "deepseek-v4-flash", "messages": [{"role": "user", "content": prompt}], "stream": False},
+            headers={"Authorization": "Bearer sk-test123456"},
+            timeout=120,
+        )
+        data = resp.json()
+        content = data.get("choices", [{}])[0].get("message", {}).get("content", "")
+
+        return {
+            "candidates": [
+                {
+                    "content": {
+                        "parts": [{"text": content}],
+                        "role": "model",
+                    },
+                    "finishReason": "STOP",
+                }
+            ],
+            "usageMetadata": {
+                "promptTokenCount": len(prompt.split()),
+                "candidatesTokenCount": len(content.split()),
+                "totalTokenCount": len(prompt.split()) + len(content.split()),
+            },
+        }
+
+
+@app.post("/v1beta/models/{model}:streamGenerateContent")
+async def gemini_stream_generate(model: str, request: Request, authorization: str = Header(...)):
+    verify_api_key(authorization)
+
+    body = await request.json()
+    contents = body.get("contents", [])
+
+    if not contents:
+        raise HTTPException(status_code=400, detail="No contents provided")
+
+    prompt = contents[-1].get("parts", [{}])[0].get("text", "")
+
+    async def stream_with_cleanup():
+        async with httpx.AsyncClient() as stream_client:
+            async with stream_client.stream(
+                "POST",
+                f"{DS2API_URL}/v1/chat/completions",
+                json={"model": "deepseek-v4-flash", "messages": [{"role": "user", "content": prompt}], "stream": True},
+                headers={"Authorization": "Bearer sk-test123456"},
+                timeout=120,
+            ) as resp:
+                async for line in resp.aiter_lines():
+                    if line.startswith("data: "):
+                        data_str = line[6:].strip()
+                        if data_str == "[DONE]":
+                            continue
+                        try:
+                            data = json.loads(data_str)
+                            content = data.get("choices", [{}])[0].get("delta", {}).get("content", "")
+                            if content:
+                                yield f"data: {json.dumps({'candidates': [{'content': {'parts': [{'text': content}], 'role': 'model'}}]})}\n\n"
+                        except json.JSONDecodeError:
+                            pass
+            
+            yield f"data: {json.dumps({'candidates': [{'content': {'parts': [], 'role': 'model'}, 'finishReason': 'STOP'}], 'usageMetadata': {'promptTokenCount': 0, 'candidatesTokenCount': 0, 'totalTokenCount': 0}})}\n\n"
+
+    return StreamingResponse(
+        stream_with_cleanup(),
+        media_type="text/event-stream",
+    )
+
+
+@app.get("/api/version")
+async def ollama_version():
+    return {"version": "0.1.0"}
+
+
+@app.get("/api/tags")
+async def ollama_tags():
+    return {
+        "models": [
+            {"name": "deepseek-chat", "model": "deepseek-chat"},
+            {"name": "deepseek-reasoner", "model": "deepseek-reasoner"},
+        ]
+    }
+
+
+@app.post("/api/show")
+async def ollama_show(request: Request):
+    body = await request.json()
+    model = body.get("model", "deepseek-chat")
+
+    return {
+        "id": model,
+        "capabilities": ["tools", "thinking"],
+    }
+
+
+@app.get("/healthz")
+async def healthz():
+    return {"status": "ok"}
+
+
+@app.get("/readyz")
+async def readyz():
+    return {"status": "ok", "accounts": {"total": 1, "in_use": 0, "available": 1}}
+
+
+@app.get("/admin/stats")
+async def admin_stats(admin_key: str = Header(...)):
+    if admin_key != ADMIN_KEY:
+        raise HTTPException(status_code=401, detail="Invalid admin key")
+
+    return {"total": 1, "in_use": 0, "available": 1, "logged_in": 1, "queue_size": 0}
+
+
+@app.get("/admin/config")
+async def get_config(admin_key: str = Header(...)):
+    if admin_key != ADMIN_KEY:
+        raise HTTPException(status_code=401, detail="Invalid admin key")
+
+    return {
+        "server": {"host": "0.0.0.0", "port": 5002},
+        "browser": {"headless": True, "max_concurrent_per_account": 1, "timeout": 60000},
+        "default_proxy": None,
+        "account_count": 1,
+    }
+
+
+def main():
+    import uvicorn
+
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=5002,
+    )
+
+
+if __name__ == "__main__":
+    main()