Update main.py

main.py

@@ -1,430 +1,735 @@
-# -*- coding:utf-8 -*-
-"""
-@Author   : g1879
-@Contact  : g1879@qq.com
-@Website  : https://DrissionPage.cn
-@Copyright: (c) 2020 by g1879, Inc. All Rights Reserved.
-"""
-from pathlib import Path
-from re import search
-
-from .options_manage import OptionsManager
-from .._functions.settings import Settings as _S
-
-
-class ChromiumOptions(object):
-    def __init__(self, read_file=True, ini_path=None):
-        self._user_data_path = None
-        self._user = 'Default'
-        self._prefs_to_del = []
-        self.clear_file_flags = False
-        self._is_headless = False
-        self._ua_set = False
-
-        if read_file is False:
-            ini_path = False
-            self.ini_path = None
-        elif ini_path:
-            ini_path = Path(ini_path).absolute()
-            if not ini_path.exists():
-                raise FileNotFoundError(_S._lang.join(_S._lang.INI_NOT_FOUND, PATH=ini_path))
-            self.ini_path = str(ini_path)
+from fastapi import FastAPI, Request, Depends, HTTPException
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from fastapi.responses import StreamingResponse, HTMLResponse
+from fastapi.background import BackgroundTasks
+from contextlib import asynccontextmanager
+import requests
+from curl_cffi import requests as cffi_requests
+import uuid
+import json
+import time
+from typing import Optional
+import asyncio
+import base64
+import tempfile
+import os
+import re
+import threading
+from DrissionPage import ChromiumPage, ChromiumOptions
+from DrissionPage.common import Settings
+import logging
+from dotenv import load_dotenv
+
+# 加载环境变量
+load_dotenv(override=True)
+
+# 配置日志
+logging.basicConfig(
+    level=logging.INFO,  # 改为 INFO 级别
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# 全局配置 DrissionPage 设置
+Settings.set_browser_connect_timeout(60)  # 增加连接超时时间
+Settings.set_language('en')  # 设置错误信息为英文，方便调试
+
+# 修改全局数据存储
+global_data = {
+    "cookie": None,
+    "cookies": None,
+    "last_update": 0,
+    "cookie_expires": 0  # 添加 cookie 过期时间
+}
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # 启动时获取 cookie
+    threading.Thread(target=get_cookie).start()
+    yield
+    # 关闭时清理资源
+    global_data["cookie"] = None
+    global_data["cookies"] = None
+    global_data["last_update"] = 0
+
+app = FastAPI(lifespan=lifespan)
+security = HTTPBearer()
+
+# OpenAI API Key 配置，可以通过环境变量覆盖
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", None)
+logger.info(f"OPENAI_API_KEY is set: {OPENAI_API_KEY is not None}")
+logger.info(f"OPENAI_API_KEY value: {OPENAI_API_KEY}")
+
+def get_cookie():
+    try:
+        logger.info("Starting cookie retrieval process...")
+        
+        # 创建配置对象
+        options = ChromiumOptions()
+        
+        # 设置浏览器路径
+        chrome_path = os.getenv('CHROME_PATH', '/usr/bin/google-chrome-stable')
+        logger.info(f"Using Chrome path: {chrome_path}")
+        options.set_browser_path(chrome_path)
+        
+        # 设置用户数据目录
+        user_data_dir = os.getenv('CHROME_USER_DATA_DIR', '/tmp/chrome-data')
+        logger.info(f"Using user data directory: {user_data_dir}")
+        options.set_user_data_path(user_data_dir)  # 使用正确的方法设置用户数据目录
+        
+        # 设置无头模式和其他参数
+        options.headless()  # 使用 headless() 方法设置无头模式
+        options.set_argument('--no-sandbox')
+        options.set_argument('--disable-dev-shm-usage')
+        options.set_argument('--disable-gpu')
+        options.set_argument('--disable-software-rasterizer')
+        options.set_argument('--disable-extensions')
+        options.set_argument('--disable-setuid-sandbox')
+        options.set_argument('--no-first-run')
+        options.set_argument('--no-zygote')
+        options.set_argument('--single-process')
+        options.set_argument('--window-size=1920,1080')
+        options.set_argument('--user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36')
+        
+        # 启用详细日志
+        options.set_argument('--enable-logging')
+        options.set_argument('--v=1')
+        
+        # 使用配置对象创建页面
+        logger.info("Creating ChromiumPage instance...")
+        page = ChromiumPage(options)
+        
+        logger.info("Navigating to target website...")
+        page.get("https://chat.akash.network/")
+        
+        logger.info("Waiting for page load...")
+        time.sleep(10)
+        
+        logger.info("Getting cookies...")
+        cookies = page.cookies()
+        if not cookies:
+            logger.error("No cookies found")
+            page.quit()
+            return None
+            
+        cookie_dict = {cookie['name']: cookie['value'] for cookie in cookies}
+        if 'cf_clearance' not in cookie_dict:
+            logger.error("cf_clearance cookie not found")
+            page.quit()
+            return None
+            
+        cookie_str = '; '.join([f"{cookie['name']}={cookie['value']}" for cookie in cookies])
+        global_data["cookie"] = cookie_str
+        global_data["last_update"] = time.time()
+        
+        expires = min([cookie.get('expires', float('inf')) for cookie in cookies])
+        if expires != float('inf'):
+            global_data["cookie_expires"] = expires
         else:
-            self.ini_path = str(Path(__file__).parent / 'configs.ini')
-
-        om = OptionsManager(ini_path)
-        options = om.chromium_options
-        self._download_path = om.paths.get('download_path', '.') or '.'
-        self._tmp_path = om.paths.get('tmp_path', None) or None
-        self._arguments = options.get('arguments', [])
-        self._browser_path = options.get('browser_path', '')
-        self._extensions = options.get('extensions', [])
-        self._prefs = options.get('prefs', {})
-        self._flags = options.get('flags', {})
-        self._address = options.get('address', None)
-        self._load_mode = options.get('load_mode', 'normal')
-        self._system_user_path = options.get('system_user_path', False)
-        self._existing_only = options.get('existing_only', False)
-        self._new_env = options.get('new_env', False)
-        for i in self._arguments:
-            if i.startswith('--headless'):
-                self._is_headless = True
-                break
-
-        self._proxy = om.proxies.get('http', None) or om.proxies.get('https', None)
-
-        user_path = user = False
-        for arg in self._arguments:
-            if arg.startswith('--user-data-dir='):
-                self.set_paths(user_data_path=arg[16:])
-                user_path = True
-            if arg.startswith('--profile-directory='):
-                self.set_user(arg[20:])
-                user = True
-            if user and user_path:
-                break
-
-        timeouts = om.timeouts
-        self._timeouts = {'base': timeouts['base'],
-                          'page_load': timeouts['page_load'],
-                          'script': timeouts['script']}
-
-        self._auto_port = options.get('auto_port', False)
-
-        others = om.others
-        self._retry_times = others.get('retry_times', 3)
-        self._retry_interval = others.get('retry_interval', 2)
-
-        return
-
-    def __repr__(self):
-        return f'<ChromiumOptions at {id(self)}>'
-
-    @property
-    def download_path(self):
-        return self._download_path
-
-    @property
-    def browser_path(self):
-        return self._browser_path
-
-    @property
-    def user_data_path(self):
-        return self._user_data_path
-
-    @property
-    def tmp_path(self):
-        return self._tmp_path
-
-    @property
-    def user(self):
-        return self._user
-
-    @property
-    def load_mode(self):
-        return self._load_mode
-
-    @property
-    def timeouts(self):
-        return self._timeouts
-
-    @property
-    def proxy(self):
-        return self._proxy
-
-    @property
-    def address(self):
-        return self._address
-
-    @property
-    def arguments(self):
-        return self._arguments
-
-    @property
-    def extensions(self):
-        return self._extensions
-
-    @property
-    def preferences(self):
-        return self._prefs
-
-    @property
-    def flags(self):
-        return self._flags
-
-    @property
-    def system_user_path(self):
-        return self._system_user_path
-
-    @property
-    def is_existing_only(self):
-        return self._existing_only
-
-    @property
-    def is_auto_port(self):
-        return self._auto_port
-
-    @property
-    def retry_times(self):
-        return self._retry_times
-
-    @property
-    def retry_interval(self):
-        return self._retry_interval
-
-    @property
-    def is_headless(self):
-        return self._is_headless
-
-    def set_retry(self, times=None, interval=None):
-        if times is not None:
-            self._retry_times = times
-        if interval is not None:
-            self._retry_interval = interval
-        return self
-
-    def set_argument(self, arg, value=None):
-        self.remove_argument(arg)
-        if value is not False:
-            if arg == '--headless':
-                if value == 'false':
-                    self._is_headless = False
-                else:
-                    if value is None:
-                        value = 'new'
-                    self._arguments.append(f'--headless={value}')
-                    self._is_headless = True
-            else:
-                arg_str = arg if value is None else f'{arg}={value}'
-                self._arguments.append(arg_str)
-        elif arg == '--headless':
-            self._is_headless = False
-        return self
-
-    def remove_argument(self, value):
-        elements_to_delete = [arg for arg in self._arguments if arg == value or arg.startswith(f'{value}=')]
-        if not elements_to_delete:
-            return self
-
-        if len(elements_to_delete) == 1:
-            self._arguments.remove(elements_to_delete[0])
+            global_data["cookie_expires"] = time.time() + 3600
+        
+        logger.info("Successfully retrieved cookies")
+        page.quit()
+        return cookie_str
+                
+    except Exception as e:
+        logger.error(f"Error fetching cookie: {str(e)}")
+        logger.error(f"Error type: {type(e)}")
+        import traceback
+        logger.error(f"Traceback: {traceback.format_exc()}")
+        return None
+
+# 添加刷新 cookie 的函数
+async def refresh_cookie():
+    logger.info("Refreshing cookie due to 401 error")
+    # 标记 cookie 为过期
+    global_data["cookie_expires"] = 0
+    # 获取新的 cookie
+    return get_cookie()
+
+async def check_and_update_cookie(background_tasks: BackgroundTasks):
+    # 如果 cookie 不存在或已过期，则更新
+    current_time = time.time()
+    if not global_data["cookie"] or current_time >= global_data["cookie_expires"]:
+        logger.info("Cookie expired or not available, refreshing...")
+        background_tasks.add_task(get_cookie)
+    else:
+        logger.info("Using existing cookie")
+
+async def get_api_key(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    token = credentials.credentials
+    logger.info(f"Received token: {token}")
+    
+    # 如果设置了 OPENAI_API_KEY，则需要验证
+    if OPENAI_API_KEY is not None:
+        # 去掉 Bearer 前缀后再比较
+        clean_token = token.replace("Bearer ", "") if token.startswith("Bearer ") else token
+        logger.info(f"Clean token: {clean_token}")
+        if clean_token != OPENAI_API_KEY:
+            logger.error(f"Token mismatch. Expected: {OPENAI_API_KEY}, Got: {clean_token}")
+            raise HTTPException(
+                status_code=401,
+                detail="Invalid API key"
+            )
+        logger.info("API key validation passed")
+    
+    return True
+
+async def validate_cookie(background_tasks: BackgroundTasks):
+    # 检查并更新 cookie（如果需要）
+    await check_and_update_cookie(background_tasks)
+    
+    # 等待 cookie 初始化完成
+    max_wait = 30  # 最大等待时间（秒）
+    start_time = time.time()
+    while not global_data["cookie"] and time.time() - start_time < max_wait:
+        await asyncio.sleep(1)
+        logger.info("Waiting for cookie initialization...")
+    
+    # 检查是否有有效的 cookie
+    if not global_data["cookie"]:
+        logger.error("Cookie not available after waiting")
+        raise HTTPException(
+            status_code=503,
+            detail="Service temporarily unavailable - Cookie not available"
+        )
+    
+    logger.info("Cookie validation passed")
+    return global_data["cookie"]
+
+async def check_image_status(session: requests.Session, job_id: str, headers: dict) -> Optional[str]:
+    """检查图片生成状态并获取生成的图片"""
+    max_retries = 30
+    for attempt in range(max_retries):
+        try:
+            print(f"\nAttempt {attempt + 1}/{max_retries} for job {job_id}")
+            response = session.get(
+                f'https://chat.akash.network/api/image-status?ids={job_id}',
+                headers=headers
+            )
+            print(f"Status response code: {response.status_code}")
+            status_data = response.json()
+            
+            if status_data and isinstance(status_data, list) and len(status_data) > 0:
+                job_info = status_data[0]
+                status = job_info.get('status')
+                print(f"Job status: {status}")
+                
+                # 只有当状态为 completed 时才处理结果
+                if status == "completed":
+                    result = job_info.get("result")
+                    if result and not result.startswith("Failed"):
+                        print("Got valid result, attempting upload...")
+                        image_url = await upload_to_xinyew(result, job_id)
+                        if image_url:
+                            print(f"Successfully uploaded image: {image_url}")
+                            return image_url
+                        print("Image upload failed")
+                        return None
+                    print("Invalid result received")
+                    return None
+                elif status == "failed":
+                    print(f"Job {job_id} failed")
+                    return None
+                
+                # 如果状态是其他（如 pending），继续等待
+                await asyncio.sleep(1)
+                continue
+                    
+        except Exception as e:
+            print(f"Error checking status: {e}")
+            return None
+    
+    print(f"Timeout waiting for job {job_id}")
+    return None
+
+@app.get("/", response_class=HTMLResponse)
+async def health_check():
+    """Health check endpoint"""
+    status = {
+        "status": "ok",
+        "version": "1.0.0",
+        "cookie_status": {
+            "available": global_data["cookie"] is not None,
+            "last_update": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(global_data["last_update"])) if global_data["last_update"] > 0 else None,
+            "expires": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(global_data["cookie_expires"])) if global_data["cookie_expires"] > 0 else None
+        }
+    }
+    
+    html = f"""
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Akash API Status</title>
+        <style>
+            body {{
+                font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+                line-height: 1.6;
+                margin: 0;
+                padding: 20px;
+                background-color: #f5f5f5;
+            }}
+            .container {{
+                max-width: 800px;
+                margin: 0 auto;
+                background-color: white;
+                padding: 20px;
+                border-radius: 8px;
+                box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            }}
+            h1 {{
+                color: #333;
+                margin-top: 0;
+            }}
+            .status {{
+                display: inline-block;
+                padding: 4px 8px;
+                border-radius: 4px;
+                font-weight: bold;
+                background-color: #4CAF50;
+                color: white;
+            }}
+            .info {{
+                margin-top: 20px;
+            }}
+            .info-item {{
+                margin-bottom: 10px;
+            }}
+            .label {{
+                font-weight: bold;
+                color: #666;
+            }}
+            .value {{
+                color: #333;
+            }}
+            .cookie-status {{
+                margin-top: 20px;
+                padding: 15px;
+                background-color: #f8f9fa;
+                border-radius: 4px;
+            }}
+            .cookie-status .available {{
+                color: {"#4CAF50" if status["cookie_status"]["available"] else "#f44336"};
+            }}
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <h1>Akash API Status <span class="status">{status["status"]}</span></h1>
+            
+            <div class="info">
+                <div class="info-item">
+                    <span class="label">Version:</span>
+                    <span class="value">{status["version"]}</span>
+                </div>
+            </div>
+            
+            <div class="cookie-status">
+                <h2>Cookie Status</h2>
+                <div class="info-item">
+                    <span class="label">Available:</span>
+                    <span class="value available">{str(status["cookie_status"]["available"])}</span>
+                </div>
+                <div class="info-item">
+                    <span class="label">Last Update:</span>
+                    <span class="value">{status["cookie_status"]["last_update"] or "Never"}</span>
+                </div>
+                <div class="info-item">
+                    <span class="label">Expires:</span>
+                    <span class="value">{status["cookie_status"]["expires"] or "Unknown"}</span>
+                </div>
+            </div>
+        </div>
+    </body>
+    </html>
+    """
+    
+    return html
+
+@app.post("/v1/chat/completions")
+async def chat_completions(
+    request: Request,
+    background_tasks: BackgroundTasks,
+    api_key: bool = Depends(get_api_key),
+    cookie: str = Depends(validate_cookie)
+):
+    try:
+        data = await request.json()
+        
+        chat_id = str(uuid.uuid4()).replace('-', '')[:16]
+        
+        akash_data = {
+            "id": chat_id,
+            "messages": data.get('messages', []),
+            "model": data.get('model', "DeepSeek-R1"),
+            "system": data.get('system_message', "You are a helpful assistant."),
+            "temperature": data.get('temperature', 0.6),
+            "topP": data.get('top_p', 0.95)
+        }
+        
+        # 构建请求头
+        headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+            "Accept": "*/*",
+            "Accept-Language": "en-US,en;q=0.9",
+            "Accept-Encoding": "gzip, deflate, br",
+            "Origin": "https://chat.akash.network",
+            "Referer": "https://chat.akash.network/",
+            "Sec-Fetch-Dest": "empty",
+            "Sec-Fetch-Mode": "cors",
+            "Sec-Fetch-Site": "same-origin",
+            "Connection": "keep-alive"
+        }
+        
+        # 设置 Cookie
+        headers["Cookie"] = cookie
+        
+        with requests.Session() as session:
+            response = session.post(
+                'https://chat.akash.network/api/chat',
+                json=akash_data,
+                headers=headers,
+                stream=True
+            )
+            
+            # 检查响应状态码，如果是 401，尝试刷新 cookie 并重试
+            if response.status_code == 401:
+                logger.info("Cookie expired, refreshing...")
+                new_cookie = await refresh_cookie()
+                if new_cookie:
+                    headers["Cookie"] = new_cookie
+                    response = session.post(
+                        'https://chat.akash.network/api/chat',
+                        json=akash_data,
+                        headers=headers,
+                        stream=True
+                    )
+            
+            if response.status_code != 200:
+                logger.error(f"Akash API error: {response.text}")
+                raise HTTPException(
+                    status_code=response.status_code,
+                    detail=f"Akash API error: {response.text}"
+            )
+            
+            def generate():
+                content_buffer = ""
+                for line in response.iter_lines():
+                    if not line:
+                        continue
+                        
+                    try:
+                        line_str = line.decode('utf-8')
+                        msg_type, msg_data = line_str.split(':', 1)
+                        
+                        if msg_type == '0':
+                            if msg_data.startswith('"') and msg_data.endswith('"'):
+                                msg_data = msg_data.replace('\\"', '"')
+                                msg_data = msg_data[1:-1]
+                            msg_data = msg_data.replace("\\n", "\n")
+                            
+                            # 在处理消息时先判断模型类型
+                            if data.get('model') == 'AkashGen' and "<image_generation>" in msg_data:
+                                # 图片生成模型的特殊处理
+                                async def process_and_send():
+                                    messages = await process_image_generation(msg_data, session, headers, chat_id)
+                                    if messages:
+                                        return messages
+                                    return None
+
+                                # 创建新的事件循环
+                                loop = asyncio.new_event_loop()
+                                asyncio.set_event_loop(loop)
+                                try:
+                                    result_messages = loop.run_until_complete(process_and_send())
+                                finally:
+                                    loop.close()
+                                
+                                if result_messages:
+                                    for message in result_messages:
+                                        yield f"data: {json.dumps(message)}\n\n"
+                                    continue
+                            
+                            content_buffer += msg_data
+                            
+                            chunk = {
+                                "id": f"chatcmpl-{chat_id}",
+                                "object": "chat.completion.chunk",
+                                "created": int(time.time()),
+                                "model": data.get('model'),
+                                "choices": [{
+                                    "delta": {"content": msg_data},
+                                    "index": 0,
+                                    "finish_reason": None
+                                }]
+                            }
+                            yield f"data: {json.dumps(chunk)}\n\n"
+                        
+                        elif msg_type in ['e', 'd']:
+                            chunk = {
+                                "id": f"chatcmpl-{chat_id}",
+                                "object": "chat.completion.chunk",
+                                "created": int(time.time()),
+                                "model": data.get('model'),
+                                "choices": [{
+                                    "delta": {},
+                                    "index": 0,
+                                    "finish_reason": "stop"
+                                }]
+                            }
+                            yield f"data: {json.dumps(chunk)}\n\n"
+                            yield "data: [DONE]\n\n"
+                            break
+                            
+                    except Exception as e:
+                        print(f"Error processing line: {e}")
+                        continue
+
+            return StreamingResponse(
+                generate(),
+                media_type='text/event-stream',
+                headers={
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'keep-alive',
+                    'Content-Type': 'text/event-stream'
+                }
+            )
+    
+    except Exception as e:
+        print(f"Error in chat_completions: {e}")
+        import traceback
+        print(traceback.format_exc())
+        return {"error": str(e)}
+
+@app.get("/v1/models")
+async def list_models(
+    background_tasks: BackgroundTasks,
+    cookie: str = Depends(validate_cookie)
+):
+    try:
+        headers = {
+            "accept": "application/json",
+            "accept-language": "en-US,en;q=0.9",
+            "sec-ch-ua": '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"macOS"',
+            "sec-fetch-dest": "document",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+            "referer": "https://chat.akash.network/"
+        }
+        
+        # 设置 Cookie
+        headers["Cookie"] = cookie
+        
+        print(f"Using cookie: {headers.get('Cookie', 'None')}")
+        print("Sending request to get models...")
+        
+        response = requests.get(
+            'https://chat.akash.network/api/models',
+            headers=headers
+        )
+        
+        print(f"Models response status: {response.status_code}")
+        print(f"Models response headers: {response.headers}")
+        
+        if response.status_code == 401:
+            print("Authentication failed. Please check your API key.")
+            return {"error": "Authentication failed. Please check your API key."}
+        
+        akash_response = response.json()
+        
+        # 添加错误处理和调试信息
+        print(f"Akash API response: {akash_response}")
+        
+        # 检查响应格式并适配
+        models_list = []
+        if isinstance(akash_response, list):
+            # 如果直接是列表
+            models_list = akash_response
+        elif isinstance(akash_response, dict):
+            # 如果是字典格式
+            models_list = akash_response.get("models", [])
         else:
-            self._arguments = [arg for arg in self._arguments if arg not in elements_to_delete]
-
-        return self
-
-    def add_extension(self, path):
-        path = Path(path)
-        if not path.exists():
-            raise FileNotFoundError(_S._lang.join(_S._lang.EXT_NOT_FOUND, PATH=path))
-        self._extensions.append(str(path))
-        return self
-
-    def remove_extensions(self):
-        self._extensions = []
-        return self
-
-    def set_pref(self, arg, value):
-        self._prefs[arg] = value
-        return self
-
-    def remove_pref(self, arg):
-        self._prefs.pop(arg, None)
-        return self
-
-    def remove_pref_from_file(self, arg):
-        self._prefs_to_del.append(arg)
-        return self
-
-    def set_flag(self, flag, value=None):
-        if value is False:
-            self._flags.pop(flag, None)
+            print(f"Unexpected response format: {type(akash_response)}")
+            models_list = []
+        
+        # 转换为标准 OpenAI 格式
+        openai_models = {
+            "object": "list",
+            "data": [
+                {
+                    "id": model["id"] if isinstance(model, dict) else model,
+                    "object": "model",
+                    "created": int(time.time()),
+                    "owned_by": "akash",
+                    "permission": [{
+                        "id": f"modelperm-{model['id'] if isinstance(model, dict) else model}",
+                        "object": "model_permission",
+                        "created": int(time.time()),
+                        "allow_create_engine": False,
+                        "allow_sampling": True,
+                        "allow_logprobs": True,
+                        "allow_search_indices": False,
+                        "allow_view": True,
+                        "allow_fine_tuning": False,
+                        "organization": "*",
+                        "group": None,
+                        "is_blocking": False
+                    }]
+                } for model in models_list
+            ]
+        }
+        
+        return openai_models
+        
+    except Exception as e:
+        print(f"Error in list_models: {e}")
+        import traceback
+        print(traceback.format_exc())
+        return {"error": str(e)}
+
+async def process_image_generation(msg_data: str, session: requests.Session, headers: dict, chat_id: str) -> Optional[list]:
+    """处理图片生成的逻辑，返回多个消息块"""
+    match = re.search(r"jobId='([^']+)' prompt='([^']+)' negative='([^']*)'", msg_data)
+    if match:
+        job_id, prompt, negative = match.groups()
+        print(f"Starting image generation process for job_id: {job_id}")
+        
+        # 记录开始时间
+        start_time = time.time()
+        
+        # 发送思考开始的消息
+        think_msg = "<think>\n"
+        think_msg += "🎨 Generating image...\n\n"
+        think_msg += f"Prompt: {prompt}\n"
+        
+        # 检查图片状态和上传
+        result = await check_image_status(session, job_id, headers)
+        
+        # 计算实际花费的时间
+        elapsed_time = time.time() - start_time
+        
+        # 完成思考部分
+        think_msg += f"\n🤔 Thinking for {elapsed_time:.1f}s...\n"
+        think_msg += "</think>"
+        
+        # 返回两个独立的消息块
+        messages = []
+        
+        # 第一个消息块：思考过程
+        messages.append({
+            "id": f"chatcmpl-{chat_id}-think",
+            "object": "chat.completion.chunk",
+            "created": int(time.time()),
+            "model": "AkashGen",
+            "choices": [{
+                "delta": {"content": think_msg},
+                "index": 0,
+                "finish_reason": None
+            }]
+        })
+        
+        # 第二个消息块：图片结果
+        if result:
+            image_msg = f"\n\n![Generated Image]({result})"
+            messages.append({
+                "id": f"chatcmpl-{chat_id}-image",
+                "object": "chat.completion.chunk",
+                "created": int(time.time()),
+                "model": "AkashGen",
+                "choices": [{
+                    "delta": {"content": image_msg},
+                    "index": 0,
+                    "finish_reason": None
+                }]
+            })
         else:
-            self._flags[flag] = value
-        return self
-
-    def clear_flags_in_file(self):
-        self.clear_file_flags = True
-        return self
-
-    def clear_flags(self):
-        self._flags = {}
-        return self
-
-    def clear_arguments(self):
-        self._arguments = []
-        return self
-
-    def clear_prefs(self):
-        self._prefs = {}
-        return self
-
-    def set_timeouts(self, base=None, page_load=None, script=None):
-        if base is not None:
-            self._timeouts['base'] = base
-        if page_load is not None:
-            self._timeouts['page_load'] = page_load
-        if script is not None:
-            self._timeouts['script'] = script
-
-        return self
-
-    def set_user(self, user='Default'):
-        self.set_argument('--profile-directory', user)
-        self._user = user
-        return self
-
-    def headless(self, on_off=True):
-        on_off = 'new' if on_off else on_off
-        return self.set_argument('--headless', on_off)
-
-    def no_imgs(self, on_off=True):
-        on_off = None if on_off else False
-        return self.set_argument('--blink-settings=imagesEnabled=false', on_off)
-
-    def no_js(self, on_off=True):
-        on_off = None if on_off else False
-        return self.set_argument('--disable-javascript', on_off)
-
-    def mute(self, on_off=True):
-        on_off = None if on_off else False
-        return self.set_argument('--mute-audio', on_off)
-
-    def incognito(self, on_off=True):
-        on_off = None if on_off else False
-        self.set_argument('--incognito', on_off)
-        return self.set_argument('--inprivate', on_off)  # edge
-
-    def new_env(self, on_off=True):
-        self._new_env = on_off
-        return self
-
-    def ignore_certificate_errors(self, on_off=True):
-        on_off = None if on_off else False
-        return self.set_argument('--ignore-certificate-errors', on_off)
-
-    def set_user_agent(self, user_agent):
-        return self.set_argument('--user-agent', user_agent)
-
-    def set_proxy(self, proxy):
-        if search(r'.*?:.*?@.*?\..*', proxy):
-            print(_S._lang.UNSUPPORTED_USER_PROXY)
-        if proxy.lower().startswith('socks'):
-            print(_S._lang.UNSUPPORTED_SOCKS_PROXY)
-        self._proxy = proxy
-        return self.set_argument('--proxy-server', proxy)
-
-    def set_load_mode(self, value):
-        if value not in ('normal', 'eager', 'none'):
-            raise ValueError(_S._lang.join(_S._lang.INCORRECT_VAL_, 'value',
-                                           ALLOW_VAL="'normal', 'eager', 'none'", CURR_VAL=value))
-        self._load_mode = value.lower()
-        return self
-
-    def set_paths(self, browser_path=None, local_port=None, address=None, download_path=None,
-                  user_data_path=None, cache_path=None):
-        """快捷的路径设置函数
-        :param browser_path: 浏览器可执行文件路径
-        :param local_port: 本地端口号
-        :param address: 调试浏览器地址，例：127.0.0.1:9222
-        :param download_path: 下载文件路径
-        :param user_data_path: 用户数据路径
-        :param cache_path: 缓存路径
-        :return: 当前对象
-        """
-        if browser_path is not None:
-            self.set_browser_path(browser_path)
-
-        if local_port is not None:
-            self.set_local_port(local_port)
-
-        if address is not None:
-            self.set_address(address)
-
-        if download_path is not None:
-            self.set_download_path(download_path)
-
-        if user_data_path is not None:
-            self.set_user_data_path(user_data_path)
-
-        if cache_path is not None:
-            self.set_cache_path(cache_path)
-
-        return self
-
-    def set_local_port(self, port):
-        self._address = f'127.0.0.1:{port}'
-        self._auto_port = False
-        return self
-
-    def set_address(self, address):
-        address = address.replace('localhost', '127.0.0.1').lstrip('htps:/')
-        self._address = address
-        return self
-
-    def set_browser_path(self, path):
-        self._browser_path = str(path)
-        return self
-
-    def set_download_path(self, path):
-        self._download_path = '.' if path is None else str(path)
-        return self
-
-    def set_tmp_path(self, path):
-        self._tmp_path = str(path)
-        return self
-
-    def set_user_data_path(self, path):
-        u = str(path)
-        self.set_argument('--user-data-dir', u)
-        self._user_data_path = u
-        self._auto_port = False
-        return self
-
-    def set_cache_path(self, path):
-        self.set_argument('--disk-cache-dir', str(path))
-        return self
-
-    def use_system_user_path(self, on_off=True):
-        self._system_user_path = on_off
-        return self
-
-    def auto_port(self, on_off=True, scope=None):
-        if on_off:
-            self._auto_port = scope if scope else (9600, 59600)
-        else:
-            self._auto_port = False
-        return self
-
-    def existing_only(self, on_off=True):
-        self._existing_only = on_off
-        return self
-
-    def save(self, path=None):
-        if path == 'default':
-            path = (Path(__file__).parent / 'configs.ini').absolute()
-
-        elif path is None:
-            if self.ini_path:
-                path = Path(self.ini_path).absolute()
+            fail_msg = "\n\n*Image generation or upload failed.*"
+            messages.append({
+                "id": f"chatcmpl-{chat_id}-fail",
+                "object": "chat.completion.chunk",
+                "created": int(time.time()),
+                "model": "AkashGen",
+                "choices": [{
+                    "delta": {"content": fail_msg},
+                    "index": 0,
+                    "finish_reason": None
+                }]
+            })
+        
+        return messages
+    return None
+
+async def upload_to_xinyew(image_base64: str, job_id: str) -> Optional[str]:
+    """上传图片到新野图床并返回URL"""
+    try:
+        print(f"\n=== Starting image upload for job {job_id} ===")
+        print(f"Base64 data length: {len(image_base64)}")
+        
+        # 解码base64图片数据
+        try:
+            image_data = base64.b64decode(image_base64.split(',')[1] if ',' in image_base64 else image_base64)
+            print(f"Decoded image data length: {len(image_data)} bytes")
+        except Exception as e:
+            print(f"Error decoding base64: {e}")
+            print(f"First 100 chars of base64: {image_base64[:100]}...")
+            return None
+        
+        # 创建临时文件
+        with tempfile.NamedTemporaryFile(suffix='.jpeg', delete=False) as temp_file:
+            temp_file.write(image_data)
+            temp_file_path = temp_file.name
+        
+        try:
+            filename = f"{job_id}.jpeg"
+            print(f"Using filename: {filename}")
+            
+            # 准备文件上传
+            files = {
+                'file': (filename, open(temp_file_path, 'rb'), 'image/jpeg')
+            }
+            
+            print("Sending request to xinyew.cn...")
+            response = requests.post(
+                'https://api.xinyew.cn/api/jdtc',
+                files=files,
+                timeout=30
+            )
+            
+            print(f"Upload response status: {response.status_code}")
+            if response.status_code == 200:
+                result = response.json()
+                print(f"Upload response: {result}")
+                
+                if result.get('errno') == 0:
+                    url = result.get('data', {}).get('url')
+                    if url:
+                        print(f"Successfully got image URL: {url}")
+                        return url
+                    print("No URL in response data")
+                else:
+                    print(f"Upload failed: {result.get('message')}")
             else:
-                path = (Path(__file__).parent / 'configs.ini').absolute()
-
-        else:
-            path = Path(path).absolute()
-
-        path = path / 'config.ini' if path.is_dir() else path
-
-        if path.exists():
-            om = OptionsManager(path)
-        else:
-            om = OptionsManager(self.ini_path or (Path(__file__).parent / 'configs.ini'))
-
-        # 设置chromium_options
-        attrs = ('address', 'browser_path', 'arguments', 'extensions', 'user', 'load_mode',
-                 'auto_port', 'system_user_path', 'existing_only', 'flags', 'new_env')
-        for i in attrs:
-            om.set_item('chromium_options', i, self.__getattribute__(f'_{i}'))
-        # 设置代理
-        om.set_item('proxies', 'http', self._proxy or '')
-        om.set_item('proxies', 'https', self._proxy or '')
-        # 设置路径
-        om.set_item('paths', 'download_path', self._download_path or '')
-        om.set_item('paths', 'tmp_path', self._tmp_path or '')
-        # 设置timeout
-        om.set_item('timeouts', 'base', self._timeouts['base'])
-        om.set_item('timeouts', 'page_load', self._timeouts['page_load'])
-        om.set_item('timeouts', 'script', self._timeouts['script'])
-        # 设置重试
-        om.set_item('others', 'retry_times', self.retry_times)
-        om.set_item('others', 'retry_interval', self.retry_interval)
-        # 设置prefs
-        om.set_item('chromium_options', 'prefs', self._prefs)
-
-        path = str(path)
-        om.save(path)
-
-        return path
-
-    def save_to_default(self):
-        return self.save('default')
+                print(f"Upload failed with status {response.status_code}")
+                print(f"Response content: {response.text}")
+            return None
+                
+        finally:
+            # 清理临时文件
+            try:
+                os.unlink(temp_file_path)
+            except Exception as e:
+                print(f"Error removing temp file: {e}")
+            
+    except Exception as e:
+        print(f"Error in upload_to_xinyew: {e}")
+        import traceback
+        print(traceback.format_exc())
+        return None
+
+if __name__ == '__main__':
+    import uvicorn
+    uvicorn.run(app, host='0.0.0.0', port=9000)