Update app.py

app.py

@@ -93,6 +93,7 @@ CONFIG = {
         "grok-3-reasoning": "grok-3"
     },
     "API": {
+        "IS_TEMP_CONVERSATION": os.environ.get("IS_TEMP_CONVERSATION", "true").lower() == "true",
         "IS_CUSTOM_SSO": os.environ.get("IS_CUSTOM_SSO", "false").lower() == "true",
         "BASE_URL": "https://grok.com",
         "API_KEY": os.environ.get("API_KEY", "sk-123456"),
@@ -103,9 +104,12 @@ CONFIG = {
         "PROXY": os.environ.get("PROXY") or None
     },
     "SERVER": {
+        "COOKIE": None,
+        "CF_CLEARANCE":os.environ.get("CF_CLEARANCE") or None,
         "PORT": int(os.environ.get("PORT", 5200))
     },
     "RETRY": {
+        "RETRYSWITCH": False,
         "MAX_ATTEMPTS": 2
     },
     "SHOW_THINKING": os.environ.get("SHOW_THINKING") == "true",
@@ -216,14 +220,48 @@ class AuthTokenManager:
         except Exception as error:
             logger.error(f"令牌删除失败: {str(error)}")
             return False
-
-    def get_next_token_for_model(self, model_id):
+    def reduce_token_request_count(self, model_id, count):
+        try:
+            normalized_model = self.normalize_model_name(model_id)
+            
+            if normalized_model not in self.token_model_map:
+                logger.error(f"模型 {normalized_model} 不存在", "TokenManager")
+                return False
+                
+            if not self.token_model_map[normalized_model]:
+                logger.error(f"模型 {normalized_model} 没有可用的token", "TokenManager")
+                return False
+                
+            token_entry = self.token_model_map[normalized_model][0]
+            
+            # 确保RequestCount不会小于0
+            new_count = max(0, token_entry["RequestCount"] - count)
+            reduction = token_entry["RequestCount"] - new_count
+            
+            token_entry["RequestCount"] = new_count
+            
+            # 更新token状态
+            if token_entry["token"]:
+                sso = token_entry["token"].split("sso=")[1].split(";")[0]
+                if sso in self.token_status_map and normalized_model in self.token_status_map[sso]:
+                    self.token_status_map[sso][normalized_model]["totalRequestCount"] = max(
+                        0, 
+                        self.token_status_map[sso][normalized_model]["totalRequestCount"] - reduction
+                    )
+            return True
+            
+        except Exception as error:
+            logger.error(f"重置校对token请求次数时发生错误: {str(error)}", "TokenManager")
+            return False
+    def get_next_token_for_model(self, model_id, is_return=False):
         normalized_model = self.normalize_model_name(model_id)
 
         if normalized_model not in self.token_model_map or not self.token_model_map[normalized_model]:
             return None
 
         token_entry = self.token_model_map[normalized_model][0]
+        if is_return:
+            return token_entry["token"]
 
         if token_entry:
             if token_entry["StartCallTime"] is None:
@@ -376,6 +414,14 @@ class AuthTokenManager:
             for entry in model_tokens:
                 all_tokens.add(entry["token"])
         return list(all_tokens)
+    def get_current_token(self, model_id):
+        normalized_model = self.normalize_model_name(model_id)
+
+        if normalized_model not in self.token_model_map or not self.token_model_map[normalized_model]:
+            return None
+
+        token_entry = self.token_model_map[normalized_model][0]
+        return token_entry["token"]
 
     def get_token_status_map(self):
         return self.token_status_map
@@ -400,8 +446,8 @@ class Utils:
         return '\n\n'.join(formatted_results)
 
     @staticmethod
-    def create_auth_headers(model):
-        return token_manager.get_next_token_for_model(model)
+    def create_auth_headers(model, is_return=False):
+        return token_manager.get_next_token_for_model(model, is_return)
 
     @staticmethod
     def get_proxy_options():
@@ -410,12 +456,17 @@ class Utils:
 
         if proxy:
             logger.info(f"使用代理: {proxy}", "Server")
-            proxy_options["proxies"] = {"https": proxy, "http": proxy}
-
+            
             if proxy.startswith("socks5://"):
-                proxy_options["proxies"] = {"https": proxy, "http": proxy}
-                proxy_options["proxy_type"] = "socks5"
-
+                proxy_options["proxy"] = proxy
+            
+                if '@' in proxy:
+                    auth_part = proxy.split('@')[0].split('://')[1]
+                    if ':' in auth_part:
+                        username, password = auth_part.split(':')
+                        proxy_options["proxy_auth"] = (username, password)
+            else:
+                proxy_options["proxies"] = {"https": proxy, "http": proxy}     
         return proxy_options
 
 class GrokApiClient:
@@ -444,7 +495,40 @@ class GrokApiClient:
             "mimeType": mime_type,
             "fileName": file_name
         }
+    def upload_base64_file(self, message, model):
+        try:
+            message_base64 = base64.b64encode(message.encode('utf-8')).decode('utf-8')
+            upload_data = {
+                "fileName": "message.txt",
+                "fileMimeType": "text/plain",
+                "content": message_base64
+            }
 
+            logger.info("发送文字文件请求", "Server")
+            cookie = f"{Utils.create_auth_headers(model, True)};{CONFIG['SERVER']['CF_CLEARANCE']}" 
+            proxy_options = Utils.get_proxy_options()
+            response = curl_requests.post(
+                "https://grok.com/rest/app-chat/upload-file",
+                headers={
+                    **DEFAULT_HEADERS,
+                    "Cookie":cookie
+                },
+                json=upload_data,
+                impersonate="chrome133a",
+                **proxy_options
+            )
+
+            if response.status_code != 200:
+                logger.error(f"上传文件失败,状态码:{response.status_code}", "Server")
+                return ''
+
+            result = response.json()
+            logger.info(f"上传文件成功: {result}", "Server")
+            return result.get("fileMetadataId", "")
+
+        except Exception as error:
+            logger.error(str(error), "Server")
+            return ''
     def upload_base64_image(self, base64_data, url):
         try:
             if 'data:image' in base64_data:
@@ -472,7 +556,7 @@ class GrokApiClient:
                 url,
                 headers={
                     **DEFAULT_HEADERS,
-                    "Cookie": CONFIG["API"]["SIGNATURE_COOKIE"]
+                    "Cookie":CONFIG["SERVER"]['COOKIE']
                 },
                 json=upload_data,
                 impersonate="chrome133a",
@@ -508,6 +592,9 @@ class GrokApiClient:
         messages = ''
         last_role = None
         last_content = ''
+        message_length = 0
+        convert_to_file = False
+        last_message_content = ''
         search = request["model"] in ['grok-2-search', 'grok-3-search']
 
         # 移除<think>标签及其内容和base64图片
@@ -557,7 +644,9 @@ class GrokApiClient:
 
 
             text_content = process_content(current.get("content", ""))
-
+            if is_last_message:
+                last_message_content = f"{role.upper()}: {text_content or '[图片]'}\n"
+                continue
             if text_content or (is_last_message and file_attachments):
                 if role == last_role and text_content:
                     last_content += '\n' + text_content
@@ -566,7 +655,14 @@ class GrokApiClient:
                     messages += f"{role.upper()}: {text_content or '[图片]'}\n"
                     last_content = text_content
                     last_role = role
-
+            message_length += len(messages)
+            if message_length >= 40000:
+                convert_to_file = True
+        if convert_to_file:
+            file_id = self.upload_base64_file(messages, request["model"])
+            if file_id:
+                file_attachments.insert(0, file_id)
+            messages = last_message_content.strip()
         return {
             "temporary": CONFIG["API"].get("IS_TEMP_CONVERSATION", False),
             "modelName": self.model_id,
@@ -686,7 +782,7 @@ def handle_image_response(image_url):
                 f"https://assets.grok.com/{image_url}",
                 headers={
                     **DEFAULT_HEADERS,
-                    "Cookie": CONFIG["API"]["SIGNATURE_COOKIE"]
+                    "Cookie":CONFIG["SERVER"]['COOKIE']
                 },
                 impersonate="chrome120",
                 **proxy_options
@@ -902,7 +998,20 @@ def add_token():
     except Exception as error:
         logger.error(str(error), "Server")
         return jsonify({"error": '添加sso令牌失败'}), 500
-
+    
+@app.route('/set/cf_clearance', methods=['POST'])
+def setCf_clearance():
+    auth_token = request.headers.get('Authorization', '').replace('Bearer ', '')
+    if auth_token != CONFIG["API"]["API_KEY"]:
+        return jsonify({"error": 'Unauthorized'}), 401
+    try:
+        cf_clearance = request.json.get('cf_clearance')
+        CONFIG["SERVER"]['CF_CLEARANCE'] = cf_clearance
+        return jsonify({"message": '设置cf_clearance成功'}), 200
+    except Exception as error:
+        logger.error(str(error), "Server")
+        return jsonify({"error": '设置cf_clearance失败'}), 500
+    
 @app.route('/delete/token', methods=['POST'])
 def delete_token():
     auth_token = request.headers.get('Authorization', '').replace('Bearer ', '')
@@ -936,6 +1045,7 @@ def get_models():
 
 @app.route('/v1/chat/completions', methods=['POST'])
 def chat_completions():
+    response_status_code = 500
     try:
         auth_token = request.headers.get('Authorization',
                                          '').replace('Bearer ', '')
@@ -955,63 +1065,66 @@ def chat_completions():
         retry_count = 0
         grok_client = GrokApiClient(model)
         request_payload = grok_client.prepare_chat_request(data)
+        
 
         while retry_count < CONFIG["RETRY"]["MAX_ATTEMPTS"]:
             retry_count += 1
-            CONFIG["API"]["SIGNATURE_COOKIE"] = Utils.create_auth_headers(
-                model)
+            CONFIG["API"]["SIGNATURE_COOKIE"] = Utils.create_auth_headers(model)
 
             if not CONFIG["API"]["SIGNATURE_COOKIE"]:
                 raise ValueError('该模型无可用令牌')
 
             logger.info(
-                f"当前令牌: {json.dumps(CONFIG['API']['SIGNATURE_COOKIE'], indent=2)}",
-                "Server")
+                f"当前令牌: {json.dumps(CONFIG['API']['SIGNATURE_COOKIE'], indent=2)}","Server")
             logger.info(
-                f"当前可用模型的全部可用数量: {json.dumps(token_manager.get_remaining_token_request_capacity(), indent=2)}",
-                "Server")
-
+                f"当前可用模型的全部可用数量: {json.dumps(token_manager.get_remaining_token_request_capacity(), indent=2)}","Server")
+            if CONFIG['SERVER']['CF_CLEARANCE']:
+                CONFIG["SERVER"]['COOKIE'] = f"{CONFIG['API']['SIGNATURE_COOKIE']};{CONFIG['SERVER']['CF_CLEARANCE']}" 
+            else:
+                CONFIG["SERVER"]['COOKIE'] = CONFIG['API']['SIGNATURE_COOKIE']
             try:
                 proxy_options = Utils.get_proxy_options()
                 response = curl_requests.post(
                     f"{CONFIG['API']['BASE_URL']}/rest/app-chat/conversations/new",
                     headers={
-                        **DEFAULT_HEADERS, "Cookie":
-                        CONFIG["API"]["SIGNATURE_COOKIE"]
+                        **DEFAULT_HEADERS, 
+                        "Cookie":CONFIG["SERVER"]['COOKIE']
                     },
                     data=json.dumps(request_payload),
                     impersonate="chrome133a",
                     stream=True,
                     **proxy_options)
+                logger.info(CONFIG["SERVER"]['COOKIE'],"Server")
                 if response.status_code == 200:
+                    response_status_code = 200
                     logger.info("请求成功", "Server")
-                    logger.info(
-                        f"当前{model}剩余可用令牌数: {token_manager.get_token_count_for_model(model)}",
-                        "Server")
+                    logger.info(f"当前{model}剩余可用令牌数: {token_manager.get_token_count_for_model(model)}","Server")
 
                     try:
                         if stream:
                             return Response(stream_with_context(
-                                handle_stream_response(response, model)),
-                                            content_type='text/event-stream')
+                                handle_stream_response(response, model)),content_type='text/event-stream')
                         else:
-                            content = handle_non_stream_response(
-                                response, model)
+                            content = handle_non_stream_response(response, model)
                             return jsonify(
-                                MessageProcessor.create_chat_response(
-                                    content, model))
+                                MessageProcessor.create_chat_response(content, model))
 
                     except Exception as error:
                         logger.error(str(error), "Server")
                         if CONFIG["API"]["IS_CUSTOM_SSO"]:
                             raise ValueError(f"自定义SSO令牌当前模型{model}的请求次数已失效")
-
-                        token_manager.remove_token_from_model(
-                            model, CONFIG["API"]["SIGNATURE_COOKIE"])
+                        token_manager.remove_token_from_model(model, CONFIG["API"]["SIGNATURE_COOKIE"])
                         if token_manager.get_token_count_for_model(model) == 0:
                             raise ValueError(f"{model} 次数已达上限，请切换其他模型或者重新对话")
-
+                elif response.status_code == 403:
+                    response_status_code = 403
+                    token_manager.reduce_token_request_count(model,1)#重置去除当前因为错误未成功请求的次数，确保不会因为错误未成功请求的次数导致次数上限
+                    if token_manager.get_token_count_for_model(model) == 0:
+                        raise ValueError(f"{model} 次数已达上限，请切换其他模型或者重新对话")
+                    raise ValueError(f"IP暂时被封无法破盾，请稍后重试或者更换ip")
                 elif response.status_code == 429:
+                    response_status_code = 429
+                    token_manager.reduce_token_request_count(model,1)
                     if CONFIG["API"]["IS_CUSTOM_SSO"]:
                         raise ValueError(f"自定义SSO令牌当前模型{model}的请求次数已失效")
 
@@ -1024,10 +1137,8 @@ def chat_completions():
                     if CONFIG["API"]["IS_CUSTOM_SSO"]:
                         raise ValueError(f"自定义SSO令牌当前模���{model}的请求次数已失效")
 
-                    logger.error(f"令牌异常错误状态!status: {response.status_code}",
-                                 "Server")
-                    token_manager.remove_token_from_model(
-                        model, CONFIG["API"]["SIGNATURE_COOKIE"])
+                    logger.error(f"令牌异常错误状态!status: {response.status_code}","Server")
+                    token_manager.remove_token_from_model(model, CONFIG["API"]["SIGNATURE_COOKIE"])
                     logger.info(
                         f"当前{model}剩余可用令牌数: {token_manager.get_token_count_for_model(model)}",
                         "Server")
@@ -1037,8 +1148,10 @@ def chat_completions():
                 if CONFIG["API"]["IS_CUSTOM_SSO"]:
                     raise
                 continue
-
-        raise ValueError('当前模型所有令牌都已耗尽')
+        if response_status_code == 403:
+            raise ValueError('IP暂时被封无法破盾，请稍后重试或者更换ip')
+        elif response_status_code == 500:
+            raise ValueError('当前模型所有令牌暂无可用，请稍后重试')    
 
     except Exception as error:
         logger.error(str(error), "ChatAPI")
@@ -1046,7 +1159,7 @@ def chat_completions():
             {"error": {
                 "message": str(error),
                 "type": "server_error"
-            }}), 500
+            }}), response_status_code
 
 @app.route('/', defaults={'path': ''})
 @app.route('/<path:path>')