Update app.py

app.py

@@ -389,6 +389,79 @@ class AuthTokenManager:
 
 token_manager = AuthTokenManager()
 
+class ProxyManager:
+    def __init__(self):
+        self.proxies = []
+        self.current_index = 0
+        self.proxy_lock = asyncio.Lock()
+        self.bad_proxies = set()
+        self.proxy_usage_count = {}
+        self.max_uses_per_proxy = int(os.getenv("PROXY_MAX_USES", "20"))
+        
+    async def load_proxies_from_env(self):
+        proxy_list = os.getenv("PROXIES", "").strip().split(",")
+        valid_proxies = [p.strip() for p in proxy_list if p.strip()]
+        
+        if not valid_proxies:
+            logger.warning("没有配置代理，将不使用代理服务", "ProxyManager")
+            return
+            
+        async with self.proxy_lock:
+            self.proxies = valid_proxies
+            self.proxy_usage_count = {proxy: 0 for proxy in valid_proxies}
+            logger.info(f"已加载 {len(valid_proxies)} 个代理", "ProxyManager")
+            
+    async def get_proxy(self):
+        """获取下一个可用代理"""
+        async with self.proxy_lock:
+            if not self.proxies:
+                return None
+                
+            # 按顺序尝试代理，跳过不可用的和使用次数过多的
+            tries = 0
+            while tries < len(self.proxies):
+                proxy = self.proxies[self.current_index]
+                self.current_index = (self.current_index + 1) % len(self.proxies)
+                
+                # 检查代理是否可用
+                if proxy in self.bad_proxies:
+                    tries += 1
+                    continue
+                    
+                # 检查使用次数
+                if self.proxy_usage_count.get(proxy, 0) >= self.max_uses_per_proxy:
+                    logger.info(f"代理 {proxy} 已达到最大使用次数，标记为不可用", "ProxyManager")
+                    self.bad_proxies.add(proxy)
+                    tries += 1
+                    continue
+                    
+                # 增加使用计数
+                self.proxy_usage_count[proxy] = self.proxy_usage_count.get(proxy, 0) + 1
+                return proxy
+                
+            # 所有代理都不可用
+            logger.warning("没有可用的代理", "ProxyManager")
+            return None
+            
+    async def mark_proxy_bad(self, proxy):
+        """标记不可用的代理"""
+        if not proxy:
+            return
+            
+        async with self.proxy_lock:
+            if proxy in self.proxies and proxy not in self.bad_proxies:
+                logger.info(f"标记代理 {proxy} 为不可用", "ProxyManager")
+                self.bad_proxies.add(proxy)
+                
+    async def reset_proxies(self):
+        """重置代理状态"""
+        async with self.proxy_lock:
+            self.bad_proxies.clear()
+            self.proxy_usage_count = {proxy: 0 for proxy in self.proxies}
+            logger.info("已重置所有代理状态", "ProxyManager")
+
+proxy_manager = ProxyManager()
+
 async def initialize_tokens():
     sso_array = os.getenv("SSO", "").split(',')
     logger.info("开始加载令牌", "Server")
@@ -401,6 +474,17 @@ async def initialize_tokens():
     logger.info(f"令牌加载完成，共加载: {len(token_manager.get_all_tokens())}个令牌", "Server")
     logger.info("初始化完成", "Server")
 
+async def initialize_app():
+    # 初始化令牌
+    await initialize_tokens()
+    
+    # 加载代理
+    use_proxy = os.getenv("USE_PROXY", "false").lower() == "true"
+    if use_proxy:
+        # 从环境变量加载代理
+        await proxy_manager.load_proxies_from_env()
+        logger.info("代理初始化完成", "Server")
+
 class Utils:
     @staticmethod
     async def organize_search_results(search_results):
@@ -427,12 +511,22 @@ class Utils:
         )
 
 class GrokApiClient:
-    def __init__(self, model_id):
+    def __init__(self, model_id, proxy=None):
         if model_id not in CONFIG["MODELS"]:
             raise ValueError(f"不支持的模型: {model_id}")
         self.model = model_id
         self.model_id = CONFIG["MODELS"][model_id]
-        self.scraper = cloudscraper.create_scraper()
+        self.proxy = proxy
+        self.scraper = self._create_scraper()
+        
+    def _create_scraper(self):
+        scraper = cloudscraper.create_scraper()
+        if self.proxy:
+            scraper.proxies = {
+                "http": self.proxy,
+                "https": self.proxy
+            }
+        return scraper
         
     def process_message_content(self, content):
         if isinstance(content, str):
@@ -527,7 +621,9 @@ class GrokApiClient:
         def remove_think_tags(text):
             import re
             text = re.sub(r'<think>[\s\S]*?<\/think>', '', text).strip()
-            text = re.sub(r'!\[image\]\(data:.*?base64,.*?\)', '[图片]', text)
+            text = re.sub(r'!$$
+image
+$$$data:.*?base64,.*?$', '[图片]', text)
             return text
             
         async def process_image_url(content):
@@ -628,6 +724,7 @@ class MessageProcessor:
                 "choices": [{
                     "index": 0,
                     "delta": {
+                        
                         "content": message
                     }
                 }]
@@ -754,6 +851,15 @@ async def stream_response_generator(response, model):
         logger.error(f"流式响应总体错误: {str(error)}", "Server")
         raise error
 
+async def handle_image_response(image_url, model):
+    try:
+        logger.info(f"处理图片回复: {image_url}", "Server")
+        image_markdown = f"![image]({image_url})"
+        return image_markdown
+    except Exception as error:
+        logger.error(error, "Server")
+        return ""
+
 async def handle_normal_response(response, model):
     try:
         full_response = ''
@@ -822,301 +928,272 @@ async def handle_normal_response(response, model):
                 continue
                 
         if CONFIG["IS_IMG_GEN2"] and image_url:
-            data_image = await handle_image_response(image_url, model)
-            return MessageProcessor.create_chat_response(data_image, model)
-        else:
-            return MessageProcessor.create_chat_response(full_response, model)
+            full_response += f"\n![image]({image_url})"
             
+        return full_response
+        
     except Exception as error:
-        logger.error(f"非流式响应总体错误: {str(error)}", "Server")
+        logger.error(error, "Server")
         raise error
 
-async def handle_image_response(image_url,model):
-    MAX_RETRIES = 2
-    retry_count = 0
-    scraper = cloudscraper.create_scraper()
-    
-    while retry_count < MAX_RETRIES:
-        try:
-            token = token_manager.get_next_token_for_model(model)
-            if not token:
-                raise ValueError("没有可用的token")
-                
-            image_response = await Utils.run_in_executor(
-                scraper.get,
-                f"https://assets.grok.com/{image_url}",
-                headers={
-                    **CONFIG["DEFAULT_HEADERS"],
-                    "cookie": token
-                }
-            )
-            
-            if image_response.status_code == 200:
-                break
-                
-            retry_count += 1
-            if retry_count == MAX_RETRIES:
-                raise ValueError(f"上游服务请求失败! status: {image_response.status_code}")
-                
-            await asyncio.sleep(1 * retry_count)
-            
-        except Exception as error:
-            logger.error(error, "Server")
-            retry_count += 1
-            if retry_count == MAX_RETRIES:
-                raise error
-                
-            await asyncio.sleep(1 * retry_count)
-    
-    image_content = image_response.content
-    
-    if CONFIG["API"]["PICGO_KEY"]:
-        form = aiohttp.FormData()
-        form.add_field('source', 
-                      io.BytesIO(image_content),
-                      filename=f'image-{int(datetime.now().timestamp())}.jpg',
-                      content_type='image/jpeg')
-        
-        async with aiohttp.ClientSession() as session:
-            async with session.post(
-                "https://www.picgo.net/api/1/upload",
-                data=form,
-                headers={"X-API-Key": CONFIG["API"]["PICGO_KEY"]}
-            ) as response_url:
-                if response_url.status != 200:
-                    return "生图失败，请查看PICGO图床密钥是否设置正确"
-                else:
-                    logger.info("生图成功", "Server")
-                    result = await response_url.json()
-                    return f"![image]({result['image']['url']})"
-    elif CONFIG["API"]["TUMY_KEY"]:
-        form = aiohttp.FormData()
-        form.add_field('file', 
-                      io.BytesIO(image_content),
-                      filename=f'image-{int(datetime.now().timestamp())}.jpg',
-                      content_type='image/jpeg')
-        
-        async with aiohttp.ClientSession() as session:
-            async with session.post(
-                "https://tu.my/api/v1/upload",
-                data=form,
-                headers={
-                    "Accept": "application/json",
-                    "Authorization": f"Bearer {CONFIG['API']['TUMY_KEY']}"
-                }
-            ) as response_url:
-                if response_url.status != 200:
-                    return "生图失败，请查看TUMY图床密钥是否设置正确"
-                else:
-                    logger.info("生图成功", "Server")
-                    result = await response_url.json()
-                    return f"![image]({result['image']['url']})"
-    # 如果没有PICGO_KEY或者TUMY_KEY则返回base64图片
-    image_base64 = base64.b64encode(image_content).decode('utf-8')
-    return f"![image](data:image/jpeg;base64,{image_base64})"
-
-
 app = Quart(__name__)
-app = cors(app, allow_origin="*", allow_methods=["GET", "POST", "OPTIONS"], allow_headers=["Content-Type", "Authorization"])
+app = cors(app, allow_origin="*")
 
 @app.before_request
 async def before_request():
     await logger.request_logger(request)
-
-@app.route('/v1/models', methods=['GET'])
-async def models():
-    return jsonify({
-        "object": "list",
-        "data": [
-            {
-                "id": model,
-                "object": "model",
-                "created": int(datetime.now().timestamp()),
-                "owned_by": "grok"
-            } for model in CONFIG["MODELS"].keys()
-        ]
-    })
-
-
-@app.route('/get/tokens', methods=['GET'])
-async def get_tokens():
-    auth_token = request.headers.get('Authorization', '').replace('Bearer ', '')
     
-    if CONFIG["API"]["IS_CUSTOM_SSO"]:
-        return jsonify({"error": '自定义的SSO令牌模式无法获取轮询sso令牌状态'}), 403
-    elif auth_token != CONFIG["API"]["API_KEY"]:
-        return jsonify({"error": 'Unauthorized'}), 401
-        
-    return jsonify(token_manager.get_token_status_map())
+@app.route('/')
+async def index():
+    return 'Grok API is running'
 
-@app.route('/add/token', methods=['POST'])
-async def add_token():
-    auth_token = request.headers.get('Authorization', '').replace('Bearer ', '')
-    
-    if CONFIG["API"]["IS_CUSTOM_SSO"]:
-        return jsonify({"error": '自定义的SSO令牌模式无法添加sso令牌'}), 403
-    elif auth_token != CONFIG["API"]["API_KEY"]:
-        return jsonify({"error": 'Unauthorized'}), 401
-        
+@app.route('/verify-sso', methods=['POST'])
+async def verify_sso():
     try:
         data = await request.get_json()
-        sso = data.get('sso')
-        if not sso:
-            return jsonify({"error": 'SSO令牌不能为空'}), 400
+        sso_token = data.get('sso')
+        
+        if not sso_token:
+            return jsonify({"status": "error", "message": "No SSO token provided"}), 400
             
-        await token_manager.add_token(f"sso-rw={sso};sso={sso}")
-        return jsonify(token_manager.get_token_status_map().get(sso, {}))
-    except Exception as error:
-        logger.error(error, "Server")
-        return jsonify({"error": '添加sso令牌失败'}), 500
+        # 构造一个简单的请求来测试令牌
+        url = f"{CONFIG['API']['BASE_URL']}/api/models"
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+            "Cookie": f"sso-rw={sso_token};sso={sso_token}"
+        }
+        
+        scraper = cloudscraper.create_scraper()
+        response = await Utils.run_in_executor(
+            scraper.get,
+            url,
+            headers=headers
+        )
+        
+        if response.status_code == 200:
+            return jsonify({"status": "valid", "message": "SSO token is valid"}), 200
+        else:
+            return jsonify({"status": "invalid", "message": f"SSO token is invalid, status code: {response.status_code}"}), 200
+            
+    except Exception as e:
+        logger.error(f"验证SSO令牌时出错: {str(e)}", "Server")
+        return jsonify({"status": "error", "message": str(e)}), 500
 
-@app.route('/delete/token', methods=['POST'])
-async def delete_token():
-    auth_token = request.headers.get('Authorization', '').replace('Bearer ', '')
-    
-    if CONFIG["API"]["IS_CUSTOM_SSO"]:
-        return jsonify({"error": '自定义的SSO令牌模式无法删除sso令牌'}), 403
-    elif auth_token != CONFIG["API"]["API_KEY"]:
-        return jsonify({"error": 'Unauthorized'}), 401
+@app.route('/check-proxies', methods=['GET'])
+async def check_proxies():
+    try:
+        use_proxy = os.getenv("USE_PROXY", "false").lower() == "true"
+        if not use_proxy:
+            return jsonify({"status": "error", "message": "代理功能未启用"}), 400
+            
+        if not proxy_manager or not proxy_manager.proxies:
+            return jsonify({"status": "error", "message": "没有配置代理"}), 400
+            
+        return jsonify({
+            "status": "success",
+            "total": len(proxy_manager.proxies),
+            "active": len(proxy_manager.proxies) - len(proxy_manager.bad_proxies),
+            "proxies": proxy_manager.proxies,
+            "usage": proxy_manager.proxy_usage_count
+        }), 200
+    except Exception as e:
+        logger.error(f"检查代理时出错: {str(e)}", "Server")
+        return jsonify({"status": "error", "message": str(e)}), 500
+
+@app.route('/verify-all-sso', methods=['GET'])
+async def verify_all_sso():
+    try:
+        # 从 token_manager 获取所有令牌
+        all_tokens = token_manager.get_all_tokens()
+        results = {}
+        token_info = {}
+        
+        # 验证每个令牌
+        for token in all_tokens:
+            try:
+                sso = token.split("sso=")[1].split(";")[0]
+                token_info[sso] = {
+                    "usage": {}
+                }
+                
+                for model_name in CONFIG["MODELS"]:
+                    normalized_model = token_manager.normalize_model_name(model_name)
+                    if sso in token_manager.token_status_map and normalized_model in token_manager.token_status_map[sso]:
+                        token_info[sso]["usage"][model_name] = {
+                            "isValid": token_manager.token_status_map[sso][normalized_model]["isValid"],
+                            "totalRequestCount": token_manager.token_status_map[sso][normalized_model]["totalRequestCount"],
+                            "invalidatedTime": token_manager.token_status_map[sso][normalized_model]["invalidatedTime"]
+                        }
+                
+                url = f"{CONFIG['API']['BASE_URL']}/api/models"
+                headers = {
+                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+                    "Cookie": token
+                }
+                
+                scraper = cloudscraper.create_scraper()
+                response = await Utils.run_in_executor(
+                    scraper.get,
+                    url,
+                    headers=headers
+                )
+                
+                results[sso] = {
+                    "status": "valid" if response.status_code == 200 else "invalid",
+                    "statusCode": response.status_code
+                }
+                
+            except Exception as e:
+                results[sso] = {
+                    "status": "error",
+                    "message": str(e)
+                }
+                
+        return jsonify({
+            "status": "success",
+            "results": results,
+            "tokenInfo": token_info,
+            "remainingCapacity": token_manager.get_remaining_token_request_capacity()
+        }), 200
         
+    except Exception as e:
+        logger.error(f"验证所有SSO令牌时出错: {str(e)}", "Server")
+        return jsonify({"status": "error", "message": str(e)}), 500
+
+@app.route("/v1/models", methods=["GET"])
+async def list_models():
     try:
-        data = await request.get_json()
-        sso = data.get('sso')
-        if not sso:
-            return jsonify({"error": 'SSO令牌不能为空'}), 400
+        auth_key = request.headers.get("Authorization", "").replace("Bearer ", "")
+        if CONFIG["API"]["IS_CUSTOM_SSO"] and auth_key != CONFIG["API"]["API_KEY"]:
+            return {"error": "Invalid API key"}, 401
             
-        success = await token_manager.delete_token(f"sso-rw={sso};sso={sso}")
-        if success:
-            return jsonify({"message": '删除sso令牌成功'})
-        else:
-            return jsonify({"error": '删除sso令牌失败'}), 500
+        models = []
+        for model_id in CONFIG["MODELS"]:
+            models.append({
+                "id": model_id,
+                "object": "model",
+                "created": int(datetime.now().timestamp())
+            })
+            
+        return jsonify({
+            "object": "list",
+            "data": models
+        })
+        
     except Exception as error:
-        logger.error(error, "Server")
-        return jsonify({"error": '删除sso令牌失败'}), 500
+        logger.error(error, "ChatAPI")
+        return {"error": str(error)}, 500
 
-@app.route('/v1/chat/completions', methods=['POST'])
+@app.route("/v1/chat/completions", methods=["POST"])
 async def chat_completions():
     try:
         data = await request.get_json()
-        auth_token = request.headers.get('Authorization', '').replace('Bearer ', '')
-
-        if auth_token:
-            if CONFIG["API"]["IS_CUSTOM_SSO"]:
-                await token_manager.set_token(f"sso-rw={auth_token};sso={auth_token}")
-            elif auth_token != CONFIG["API"]["API_KEY"]:
-                return jsonify({"error": "Unauthorized"}), 401
-        else:
-            return jsonify({"error": "Unauthorized"}), 401
-                    
-        model = data.get("model")
-        stream = data.get("stream", False)
-        retry_count = 0
         
-        try:
-            grok_client = GrokApiClient(model)
-            request_payload = await grok_client.prepare_chat_request(data)
+        # 验证请求
+        if "model" not in data:
+            return jsonify({"error": "Missing model parameter"}), 400
             
-            while retry_count < CONFIG["RETRY"]["MAX_ATTEMPTS"]:
-                retry_count += 1
-                logger.info(f"开始请求(第{retry_count}次尝试)", "Server")
-                
-                token = token_manager.get_next_token_for_model(model)
-                if not token:
-                    logger.error(f"没有可用的{model}模型令牌", "Server")
-                    if retry_count == CONFIG["RETRY"]["MAX_ATTEMPTS"]:
-                        raise ValueError(f"没有可用的{model}模型令牌")
-                    continue
+# 获取代理# 获取代理
+use_proxy=os.getenv("USE_PROXY"，"false").lower()=="true""USE_PROXY", "false").lower() == "true"
+proxy=无None
+        
+如果使用代理服务器(_P)：if use_proxy:
+proxy=等待proxy_manager.get_proxy()await proxy_manager.get_proxy()
+如果代理：if proxy:
+Logger.info(f"使用代理：{proxy}"，"Server")f"使用代理: {proxy}", "Server")
+        
+# 创建客户端# 创建客户端
+client=GrokApiClient(数据["模型"]，proxy=proxy)"model"], proxy=proxy)
+        
+Logger.info(f"模型：{data['model']}"，"ChatAPI")f"模型: {data['model']}", "ChatAPI")
+        
+stream=data.get("stream"，False)"stream", False)
+prepared_data=等待客户端.preparate_chat_request(数据)await client.prepare_chat_request(data)
+        
+auth_key=request.Header.get("Authorization"，"").replace("Bearer"，"")"Authorization", "").replace("Bearer ", "")
+如果CONFIG["API"]["IS_CUSTOM_SSO"]和auth_key！=CONFIG["API"]["API_KEY"]：if CONFIG["API"]["IS_CUSTOM_SSO"] and auth_key != CONFIG["API"]["API_KEY"]:
+token=auth_key
+其他：else:
+token=token_manager.get_next_token_for_model(数据["model"])"model"])
+            
+如果不是令牌：if not token:
+return jsonify({"错误"："没有可用的令牌"})，500return jsonify({"error": "No available token"}), 500
+            
+标头={
+"User-Agent"："Mozilla/5.0(Windows NT10.0；Win64；x64)AppleWebKit/537.36(KHTML，如Gecko)Chrome/133.0.0.0 Safari/537.36"，"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36",
+"连接"："保持连接"，"Connection": "keep-alive",
+"Accept"："文本/事件流"，"Accept": "text/event-stream",
+"内容类型"："text/plain；charset=UTF-8"，"Content-Type": "text/plain;charset=UTF-8",
+“Cookie”：令牌"Cookie": token
+}
+        
+对于范围内的尝试(CONFIG["重试"]["MAX_ATTEMPTS"])：for attempt in range(CONFIG["RETRY"]["MAX_ATTEMPTS"]):
+尝试：try:
+Logger.info(f"开始请求(第{tempt+1}次尝试)"，"服务器")f"开始请求(第{attempt+1}次尝试)", "Server")
                 
-                scraper = cloudscraper.create_scraper()
+如果不是令牌：if not token:
+return jsonify({"错误"："没有可用的令牌"})，500return jsonify({"error": "No available token"}), 500
+                    
+如果配置["API"]["IS_CUSTOM_SSO"]：if CONFIG["API"]["IS_CUSTOM_SSO"]:
+Logger.info("使用自定义SSO"，"Server")"使用自定义SSO", "Server")
+其他：else:
+Logger.info(f"使用令牌：{token}"，"Server")f"使用令牌: {token}", "Server")
+                    
+响应=等待Utils.run_in_executor(await Utils.run_in_executor(
+client.scraper.post，
+F"{CONFIG['API']['BASE_URL']}/api/conversation"，f"{CONFIG['API']['BASE_URL']}/api/conversation",
+headers=headers，
+data=json.dumps(prepared_data)，
+stream=TrueTrue
+)
                 
-                try:
-                    headers = {
-                        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36",
-                        "Connection": "keep-alive",
-                        "Accept": "text/event-stream",
-                        "Content-Type": "text/plain;charset=UTF-8",
-                        "Cookie": token,
-                        "baggage": "sentry-public_key=b311e0f2690c81f25e2c4cf6d4f7ce1c"
-                    }
-                    logger.info(f"使用令牌: {token}", "Server")
+如果response.status_code！=200：if response.status_code != 200:
+token_manager.从模型(data["model"])中删除token_manager，令牌)"model"], token)
+如果未配置["API"]["IS_CUSTOM_SSO"]：if not CONFIG["API"]["IS_CUSTOM_SSO"]:
+token=token_manager.get_next_token_for_model(数据["model"])"model"])
+返回jsonify({"错误"：f"请求失败，状态代码：{response.status_code}"})，response.status_codereturn jsonify({"error": f"Request failed with status code: {response.status_code}"}), response.status_code
                     
-                    response = await Utils.run_in_executor(
-                        scraper.post,
-                        f"{CONFIG['API']['BASE_URL']}/rest/app-chat/conversations/new",
-                        headers=headers,
-                        data=json.dumps(request_payload),
-                        stream=True
-                    )
+Logger.info("请求成功"，"服务器")"请求成功", "Server")
+                
+if流：if stream:
+返回响应(return Response(
+stream_response_generator(响应，数据["model"])，"model"]),
+content_type="文本/事件流""text/event-stream"
+)
+其他：else:
+结果=等待句柄_正常_响应(响应，数据["模型"])await handle_normal_response(response, data["model"])
+返回jsonify(MessageProcessor.create_chat_response(结果，数据["模型"]))return jsonify(MessageProcessor.create_chat_response(result, data["model"]))
                     
-                    if response.status_code == 200:
-                        logger.info("请求成功", "Server")
-                        
-                        if stream:
-                            return Response(
-                                stream_response_generator(response, model),
-                                content_type='text/event-stream',
-                                headers={
-                                    'Cache-Control': 'no-cache',
-                                    'Connection': 'keep-alive'
-                                }
-                            )
-                        else:
-                            result = await handle_normal_response(response, model)
-                            return jsonify(result)
-                    else:
-                        logger.error(f"请求失败: 状态码 {response.status_code}", "Server")
-                        token_manager.remove_token_from_model(model, token)
-                        
-                except Exception as e:
-                    logger.error(f"请求异常: {str(e)}", "Server")
-                    token_manager.remove_token_from_model(model, token)
+例外情况除外，如e：except Exception as e:
+# 如果使用了代理且出错，标记代理为不可用# 如果使用了代理且出错，标记代理为不可用
+如果使用代理和代理并("代理连接失败"在str(e)中或str(e)中的“连接被拒绝”)：if use_proxy and proxy and ("代理连接失败" in str(e) or "Connection refused" in str(e)):
+等待proxy_manager.mark_proxy_bad(proxy)await proxy_manager.mark_proxy_bad(proxy)
+# 尝试获取新代理# 尝试获取新代理
+proxy=等待proxy_manager.get_proxy()await proxy_manager.get_proxy()
+如果代理：if proxy:
+client=GrokApiClient(数据["模型"]，proxy=proxy)"model"], proxy=proxy)
+                
+logger.error(f"尝试{尝试+1}失败：{str(e)}"，"服务器")f"尝试 {attempt+1} 失败: {str(e)}", "Server")
+                
+如果尝试==配置["重试"]["MAX_ATTEMPTS"]-1：if attempt == CONFIG["RETRY"]["MAX_ATTEMPTS"] - 1:
+提高raise
+                
+如果未配置["API"]["IS_CUSTOM_SSO"]：if not CONFIG["API"]["IS_CUSTOM_SSO"]:
+token=token_manager.get_next_token_for_model(数据["model"])"model"])
                     
-            raise ValueError("请求失败，已达到最大重试次数")
-            
-        except Exception as e:
-            logger.error(e, "ChatAPI")
-            return jsonify({
-                "error": {
-                    "message": str(e),
-                    "type": "server_error"
-                }
-            }), 500
-            
-    except Exception as e:
-        logger.error(e, "ChatAPI")
-        return jsonify({
-            "error": {
-                "message": str(e),
-                "type": "server_error"
-            }
-        }), 500
+例外情况除外，如e：except Exception as e:
+logger.error(e，"ChatAPI")"ChatAPI")
+return jsonify({"error"：str(e)})，500return jsonify({"error": str(e)}), 500
 
-@app.route('/', methods=['GET'])
-async def index():
-    return "api运行正常"
-
-if __name__ == "__main__":
-    asyncio.run(initialize_tokens())
-    app.run(host="0.0.0.0", port=CONFIG["SERVER"]["PORT"])
-    # 在现有app.py文件的最底部添加或修改这段代码
-if __name__ == "__main__":
-    # 初始化令牌
-    import asyncio
-    asyncio.run(initialize_tokens())
+if如果__name__=="__main__"："__main__":
+# 初始化应用# 初始化应用
+导入异步import asyncio
+asyncio.run(initialize_app())
     
-    # 获取端口，优先使用环境变量
-    port = int(os.getenv("PORT", CONFIG["SERVER"]["PORT"]))
-    
-    # 启动服务器
-    from hypercorn.asyncio import serve
-    from hypercorn.config import Config as HyperConfig
-    
-    config = HyperConfig()
-    config.bind = [f"0.0.0.0:{port}"]
-    config.use_reloader = True
-    
-    logger.info(f"服务器正在启动，端口：{port}", "Server")
-    asyncio.run(serve(app, config))
+# 启动服务器# 启动服务器
+port=int(os.getenv("PORT"，CONFIG["SERVER"]["PORT"]))"PORT", CONFIG["SERVER"]["PORT"]))
+App.run(主机="0.0.0.0"，端口=端口)"0.0.0.0", port=port)
+