Update app.py

app.py

@@ -389,79 +389,6 @@ 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")
@@ -474,17 +401,6 @@ 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):
@@ -511,22 +427,12 @@ class Utils:
         )
 
 class GrokApiClient:
-    def __init__(self, model_id, proxy=None):
+    def __init__(self, model_id):
         if model_id not in CONFIG["MODELS"]:
             raise ValueError(f"不支持的模型: {model_id}")
         self.model = model_id
         self.model_id = CONFIG["MODELS"][model_id]
-        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
+        self.scraper = cloudscraper.create_scraper()
         
     def process_message_content(self, content):
         if isinstance(content, str):
@@ -619,13 +525,9 @@ class GrokApiClient:
         search = request_data["model"] in ["grok-2-search", "grok-3-search"]
         
         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)
-    return text
-
-image
-$$$data:.*?base64,.*?$', '[图片]', text)
+            import re
+            text = re.sub(r'<think>[\s\S]*?<\/think>', '', text).strip()
+            text = re.sub(r'!\[image\]\(data:.*?base64,.*?\)', '[图片]', text)
             return text
             
         async def process_image_url(content):
@@ -726,7 +628,6 @@ class MessageProcessor:
                 "choices": [{
                     "index": 0,
                     "delta": {
-                        
                         "content": message
                     }
                 }]
@@ -853,15 +754,6 @@ 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 = ''
@@ -930,271 +822,294 @@ async def handle_normal_response(response, model):
                 continue
                 
         if CONFIG["IS_IMG_GEN2"] and image_url:
-            full_response += f"\n![image]({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)
             
-        return full_response
-        
     except Exception as error:
-        logger.error(error, "Server")
+        logger.error(f"非流式响应总体错误: {str(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="*")
+app = cors(app, allow_origin="*", allow_methods=["GET", "POST", "OPTIONS"], allow_headers=["Content-Type", "Authorization"])
 
 @app.before_request
 async def before_request():
     await logger.request_logger(request)
-    
-@app.route('/')
-async def index():
-    return 'Grok API is running'
 
-@app.route('/verify-sso', methods=['POST'])
-async def verify_sso():
-    try:
-        data = await request.get_json()
-        sso_token = data.get('sso')
-        
-        if not sso_token:
-            return jsonify({"status": "error", "message": "No SSO token provided"}), 400
-            
-        # 构造一个简单的请求来测试令牌
-        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
-        )
+@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
         
-        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
+    return jsonify(token_manager.get_token_status_map())
 
-@app.route('/check-proxies', methods=['GET'])
-async def check_proxies():
+@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
+        
     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
+        data = await request.get_json()
+        sso = data.get('sso')
+        if not sso:
+            return jsonify({"error": 'SSO令牌不能为空'}), 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
+        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
 
-@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
+@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
         
-    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:
-        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
-            
-        models = []
-        for model_id in CONFIG["MODELS"]:
-            models.append({
-                "id": model_id,
-                "object": "model",
-                "created": int(datetime.now().timestamp())
-            })
+        data = await request.get_json()
+        sso = data.get('sso')
+        if not sso:
+            return jsonify({"error": 'SSO令牌不能为空'}), 400
             
-        return jsonify({
-            "object": "list",
-            "data": models
-        })
-        
+        success = await token_manager.delete_token(f"sso-rw={sso};sso={sso}")
+        if success:
+            return jsonify({"message": '删除sso令牌成功'})
+        else:
+            return jsonify({"error": '删除sso令牌失败'}), 500
     except Exception as error:
-        logger.error(error, "ChatAPI")
-        return {"error": str(error)}, 500
+        logger.error(error, "Server")
+        return jsonify({"error": '删除sso令牌失败'}), 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
         
-        # 验证请求
-        if "model" not in data:
-            return jsonify({"error": "Missing model parameter"}), 400
-            
-# 获取代理# 获取代理
-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
+        try:
+            grok_client = GrokApiClient(model)
+            request_payload = await grok_client.prepare_chat_request(data)
             
-标头={
-"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")
+            while retry_count < CONFIG["RETRY"]["MAX_ATTEMPTS"]:
+                retry_count += 1
+                logger.info(f"开始请求(第{retry_count}次尝试)", "Server")
                 
-如果不是令牌：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
-)
+                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
                 
-如果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
-                    
-Logger.info("请求成功"，"服务器")"请求成功", "Server")
+                scraper = cloudscraper.create_scraper()
                 
-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"]))
+                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")
                     
-例外情况除外，如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"])
+                    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
+                    )
                     
-例外情况除外，如e：except Exception as e:
-logger.error(e，"ChatAPI")"ChatAPI")
-return jsonify({"error"：str(e)})，500return jsonify({"error": str(e)}), 500
+                    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)
+                    
+            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
 
-if如果__name__=="__main__"："__main__":
-# 初始化应用# 初始化应用
-导入异步import asyncio
-asyncio.run(initialize_app())
+@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"])
+    if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--port", type=int, default=CONFIG["SERVER"]["PORT"])
+    args = parser.parse_args()
     
-# 启动服务器# 启动服务器
-port=int(os.getenv("PORT"，CONFIG["SERVER"]["PORT"]))"PORT", CONFIG["SERVER"]["PORT"]))
-App.run(主机="0.0.0.0"，端口=端口)"0.0.0.0", port=port)
+    # 使用传入的端口覆盖配置中的端口
+    port = args.port
+    
+    # 这里使用修改后的端口启动服务
+    app.run(host="0.0.0.0", port=port)
+