Update app.py

app.py

@@ -7,18 +7,13 @@ import sys
 import inspect
 import secrets
 from loguru import logger
-from dotenv import load_dotenv
+from pathlib import Path
 
 import requests
 from flask import Flask, request, Response, jsonify, stream_with_context, render_template, redirect, session
 from curl_cffi import requests as curl_requests
 from werkzeug.middleware.proxy_fix import ProxyFix
 
-current_dir = os.path.dirname(os.path.abspath(__file__))
-env_path = os.path.join(current_dir, '.env')
-
-load_dotenv(env_path)
-
 class Logger:
     def __init__(self, level="INFO", colorize=True, format=None):
         logger.remove()
@@ -85,48 +80,54 @@ class Logger:
         self.logger.bind(**caller_info).info(f"请求: {request.method} {request.path}", "Request")
 
 logger = Logger(level="INFO")
+DATA_DIR = Path("/data")
 
-
+if not DATA_DIR.exists():
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
 CONFIG = {
     "MODELS": {
-        'grok-2': 'grok-latest',
-        'grok-2-imageGen': 'grok-latest',
-        'grok-2-search': 'grok-latest',
         "grok-3": "grok-3",
         "grok-3-search": "grok-3",
         "grok-3-imageGen": "grok-3",
         "grok-3-deepsearch": "grok-3",
-        "grok-3-reasoning": "grok-3"
+        "grok-3-deepersearch": "grok-3",
+        "grok-3-reasoning": "grok-3",
+        'grok-4': 'grok-4',
+        'grok-4-reasoning': 'grok-4',
+        'grok-4-imageGen': 'grok-4',
+        'grok-4-deepsearch': 'grok-4'
     },
     "API": {
-        "IS_TEMP_CONVERSATION": os.getenv("IS_TEMP_CONVERSATION", "true").lower() == "true",
-        "IS_CUSTOM_SSO": os.getenv("IS_CUSTOM_SSO", "false").lower() == "true",
+        "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.getenv("API_KEY", "sk-123456"),
+        "API_KEY": os.environ.get("API_KEY", "sk-123456"),
         "SIGNATURE_COOKIE": None,
-        "PICGO_KEY": os.getenv("PICGO_KEY") or None,
-        "TUMY_KEY": os.getenv("TUMY_KEY") or None,
+        "PICGO_KEY": os.environ.get("PICGO_KEY") or None,
+        "TUMY_KEY": os.environ.get("TUMY_KEY") or None,
         "RETRY_TIME": 1000,
-        "PROXY": os.getenv("PROXY") or None
+        "PROXY": os.environ.get("PROXY") or None
     },
     "ADMIN": {
-        "MANAGER_SWITCH": os.getenv("MANAGER_SWITCH") or None,
-        "PASSWORD": os.getenv("ADMINPASSWORD") or None 
+        "MANAGER_SWITCH": os.environ.get("MANAGER_SWITCH") or None,
+        "PASSWORD": os.environ.get("ADMINPASSWORD") or None 
     },
     "SERVER": {
         "COOKIE": None,
-        "CF_CLEARANCE":os.getenv("CF_CLEARANCE") or None,
-        "PORT": int(os.getenv("PORT", 5200))
+        "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.getenv("SHOW_THINKING") == "true",
+    "TOKEN_STATUS_FILE": str(DATA_DIR / "token_status.json"),
+    "SHOW_THINKING": os.environ.get("SHOW_THINKING").lower() == "true",
     "IS_THINKING": False,
     "IS_IMG_GEN": False,
     "IS_IMG_GEN2": False,
-    "ISSHOW_SEARCH_RESULTS": os.getenv("ISSHOW_SEARCH_RESULTS", "true").lower() == "true"
+    "ISSHOW_SEARCH_RESULTS": os.environ.get("ISSHOW_SEARCH_RESULTS", "true").lower() == "true",
+    "IS_SUPER_GROK": os.environ.get("IS_SUPER_GROK", "false").lower() == "true"
 }
 
 
@@ -145,7 +146,8 @@ DEFAULT_HEADERS = {
     'Sec-Fetch-Dest': 'empty',
     'Sec-Fetch-Mode': 'cors',
     'Sec-Fetch-Site': 'same-origin',
-    'Baggage': 'sentry-public_key=b311e0f2690c81f25e2c4cf6d4f7ce1c'
+    'Baggage': 'sentry-public_key=b311e0f2690c81f25e2c4cf6d4f7ce1c',
+    'x-statsig-id': 'ZTpUeXBlRXJyb3I6IENhbm5vdCByZWFkIHByb3BlcnRpZXMgb2YgdW5kZWZpbmVkIChyZWFkaW5nICdjaGlsZE5vZGVzJyk='
 }
 
 class AuthTokenManager:
@@ -153,67 +155,127 @@ class AuthTokenManager:
         self.token_model_map = {}
         self.expired_tokens = set()
         self.token_status_map = {}
-
-        self.model_config = {
-            "grok-2": {
-                "RequestFrequency": 30,
-                "ExpirationTime": 1 * 60 * 60 * 1000  # 1小时
-            },
-            "grok-3": {
-                "RequestFrequency": 20,
-                "ExpirationTime": 2 * 60 * 60 * 1000  # 2小时
-            },
-            "grok-3-deepsearch": {
-                "RequestFrequency": 10,
-                "ExpirationTime": 24 * 60 * 60 * 1000  # 24小时
-            },
-            "grok-3-reasoning": {
-                "RequestFrequency": 10,
-                "ExpirationTime": 24 * 60 * 60 * 1000  # 24小时
+        self.model_super_config = {
+                "grok-3": {
+                    "RequestFrequency": 100,
+                    "ExpirationTime": 3 * 60 * 60 * 1000  # 3小时
+                },
+                "grok-3-deepsearch": {
+                    "RequestFrequency": 30,
+                    "ExpirationTime": 24 * 60 * 60 * 1000  # 3小��
+                },
+                "grok-3-deepersearch": {
+                    "RequestFrequency": 10,
+                    "ExpirationTime": 3 * 60 * 60 * 1000  # 23小时
+                },
+                "grok-3-reasoning": {
+                    "RequestFrequency": 30,
+                    "ExpirationTime": 3 * 60 * 60 * 1000  # 3小时
+                },
+                "grok-4": {
+                    "RequestFrequency": 20,
+                    "ExpirationTime": 3 * 60 * 60 * 1000  # 3小时
+                }
             }
-        }
+        self.model_normal_config = {
+                "grok-3": {
+                    "RequestFrequency": 20,
+                    "ExpirationTime": 3 * 60 * 60 * 1000  # 3小时
+                },
+                "grok-3-deepsearch": {
+                    "RequestFrequency": 10,
+                    "ExpirationTime": 24 * 60 * 60 * 1000  # 24小时
+                },
+                "grok-3-deepersearch": {
+                    "RequestFrequency": 3,
+                    "ExpirationTime": 24 * 60 * 60 * 1000  # 24小时
+                },
+                "grok-3-reasoning": {
+                    "RequestFrequency": 8,
+                    "ExpirationTime": 24 * 60 * 60 * 1000  # 24小时
+                }
+            }
+        self.model_config = self.model_normal_config
         self.token_reset_switch = False
         self.token_reset_timer = None
+    def save_token_status(self):
+        try:        
+            with open(CONFIG["TOKEN_STATUS_FILE"], 'w', encoding='utf-8') as f:
+                json.dump(self.token_status_map, f, indent=2, ensure_ascii=False)
+            logger.info("令牌状态已保存到配置文件", "TokenManager")
+        except Exception as error:
+            logger.error(f"保存令牌状态失败: {str(error)}", "TokenManager")
+            
+    def load_token_status(self):
+        try:
+            token_status_file = Path(CONFIG["TOKEN_STATUS_FILE"])
+            if token_status_file.exists():
+                with open(token_status_file, 'r', encoding='utf-8') as f:
+                    self.token_status_map = json.load(f)
+                logger.info("已从配置文件加载令牌状态", "TokenManager")
+        except Exception as error:
+            logger.error(f"加载令牌状态失败: {str(error)}", "TokenManager")
+    def add_token(self, tokens, isinitialization=False):
+        tokenType = tokens.get("type")
+        tokenSso = tokens.get("token")
+        if tokenType == "normal":
+            self.model_config = self.model_normal_config
+        else:
+            self.model_config = self.model_super_config
+        sso = tokenSso.split("sso=")[1].split(";")[0]
 
-    def add_token(self, token):
-        sso = token.split("sso=")[1].split(";")[0]
         for model in self.model_config.keys():
             if model not in self.token_model_map:
                 self.token_model_map[model] = []
             if sso not in self.token_status_map:
                 self.token_status_map[sso] = {}
 
-            existing_token_entry = next((entry for entry in self.token_model_map[model] if entry["token"] == token), None)
+            existing_token_entry = next((entry for entry in self.token_model_map[model] if entry["token"] == tokenSso), None)
 
             if not existing_token_entry:
                 self.token_model_map[model].append({
-                    "token": token,
+                    "token": tokenSso,
+                    "MaxRequestCount": self.model_config[model]["RequestFrequency"],
                     "RequestCount": 0,
                     "AddedTime": int(time.time() * 1000),
-                    "StartCallTime": None
+                    "StartCallTime": None,
+                    "type": tokenType
                 })
 
                 if model not in self.token_status_map[sso]:
                     self.token_status_map[sso][model] = {
                         "isValid": True,
                         "invalidatedTime": None,
-                        "totalRequestCount": 0
+                        "totalRequestCount": 0,
+                        "isSuper":tokenType == "super"
                     }
+        if not isinitialization:
+            self.save_token_status()
+
+    def set_token(self, tokens):
+        tokenType = tokens.get("type")
+        tokenSso = tokens.get("token")
+        if tokenType == "normal":
+            self.model_config = self.model_normal_config
+        else:
+            self.model_config = self.model_super_config
 
-    def set_token(self, token):
         models = list(self.model_config.keys())
         self.token_model_map = {model: [{
-            "token": token,
+            "token": tokenSso,
+            "MaxRequestCount": self.model_config[model]["RequestFrequency"],
             "RequestCount": 0,
             "AddedTime": int(time.time() * 1000),
-            "StartCallTime": None
+            "StartCallTime": None,
+            "type": tokenType
         }] for model in models}
 
-        sso = token.split("sso=")[1].split(";")[0]
+        sso = tokenSso.split("sso=")[1].split(";")[0]
         self.token_status_map[sso] = {model: {
             "isValid": True,
             "invalidatedTime": None,
-            "totalRequestCount": 0
+            "totalRequestCount": 0,
+            "isSuper":tokenType == "super"
         } for model in models}
 
     def delete_token(self, token):
@@ -224,6 +286,8 @@ class AuthTokenManager:
 
             if sso in self.token_status_map:
                 del self.token_status_map[sso]
+            
+            self.save_token_status()
 
             logger.info(f"令牌已成功移除: {token}", "TokenManager")
             return True
@@ -270,10 +334,15 @@ class AuthTokenManager:
             return None
 
         token_entry = self.token_model_map[normalized_model][0]
+        logger.info(f"token_entry: {token_entry}", "TokenManager")
         if is_return:
             return token_entry["token"]
 
         if token_entry:
+            if token_entry["type"] == "super":
+                self.model_config = self.model_super_config
+            else:
+                self.model_config = self.model_normal_config
             if token_entry["StartCallTime"] is None:
                 token_entry["StartCallTime"] = int(time.time() * 1000)
 
@@ -283,18 +352,23 @@ class AuthTokenManager:
 
             token_entry["RequestCount"] += 1
 
-            if token_entry["RequestCount"] > self.model_config[normalized_model]["RequestFrequency"]:
+            if token_entry["RequestCount"] > token_entry["MaxRequestCount"]:
                 self.remove_token_from_model(normalized_model, token_entry["token"])
                 next_token_entry = self.token_model_map[normalized_model][0] if self.token_model_map[normalized_model] else None
                 return next_token_entry["token"] if next_token_entry else None
 
             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]:
                 if token_entry["RequestCount"] == self.model_config[normalized_model]["RequestFrequency"]:
                     self.token_status_map[sso][normalized_model]["isValid"] = False
                     self.token_status_map[sso][normalized_model]["invalidatedTime"] = int(time.time() * 1000)
                 self.token_status_map[sso][normalized_model]["totalRequestCount"] += 1
 
+                
+
+                self.save_token_status()
+
             return token_entry["token"]
 
         return None
@@ -314,7 +388,8 @@ class AuthTokenManager:
             self.expired_tokens.add((
                 removed_token_entry["token"],
                 normalized_model,
-                int(time.time() * 1000)
+                int(time.time() * 1000),
+                removed_token_entry["type"]
             ))
 
             if not self.token_reset_switch:
@@ -331,7 +406,7 @@ class AuthTokenManager:
         return list(self.expired_tokens)
 
     def normalize_model_name(self, model):
-        if model.startswith('grok-') and 'deepsearch' not in model and 'reasoning' not in model:
+        if model.startswith('grok-') and not any(keyword in model for keyword in ['deepsearch','deepersearch','reasoning']):
             return '-'.join(model.split('-')[:2])
         return model
 
@@ -344,8 +419,8 @@ class AuthTokenManager:
 
         for model in self.model_config.keys():
             model_tokens = self.token_model_map.get(model, [])
-            model_request_frequency = self.model_config[model]["RequestFrequency"]
-
+            
+            model_request_frequency = sum(token_entry.get("MaxRequestCount", 0) for token_entry in model_tokens)
             total_used_requests = sum(token_entry.get("RequestCount", 0) for token_entry in model_tokens)
 
             remaining_capacity = (len(model_tokens) * model_request_frequency) - total_used_requests
@@ -361,10 +436,13 @@ class AuthTokenManager:
         def reset_expired_tokens():
             now = int(time.time() * 1000)
 
+            model_config = self.model_normal_config
             tokens_to_remove = set()
             for token_info in self.expired_tokens:
-                token, model, expired_time = token_info
-                expiration_time = self.model_config[model]["ExpirationTime"]
+                token, model, expired_time ,type = token_info
+                if type == "super":
+                    model_config = self.model_super_config
+                expiration_time = model_config[model]["ExpirationTime"]
 
                 if now - expired_time >= expiration_time:
                     if not any(entry["token"] == token for entry in self.token_model_map.get(model, [])):
@@ -373,9 +451,11 @@ class AuthTokenManager:
 
                         self.token_model_map[model].append({
                             "token": token,
+                            "MaxRequestCount": model_config[model]["RequestFrequency"],
                             "RequestCount": 0,
                             "AddedTime": now,
-                            "StartCallTime": None
+                            "StartCallTime": None,
+                            "type": type
                         })
 
                     sso = token.split("sso=")[1].split(";")[0]
@@ -383,12 +463,13 @@ class AuthTokenManager:
                         self.token_status_map[sso][model]["isValid"] = True
                         self.token_status_map[sso][model]["invalidatedTime"] = None
                         self.token_status_map[sso][model]["totalRequestCount"] = 0
+                        self.token_status_map[sso][model]["isSuper"] = type == "super"
 
                     tokens_to_remove.add(token_info)
 
             self.expired_tokens -= tokens_to_remove
 
-            for model in self.model_config.keys():
+            for model in model_config.keys():
                 if model not in self.token_model_map:
                     continue
 
@@ -396,13 +477,14 @@ class AuthTokenManager:
                     if not token_entry.get("StartCallTime"):
                         continue
 
-                    expiration_time = self.model_config[model]["ExpirationTime"]
+                    expiration_time = model_config[model]["ExpirationTime"]
                     if now - token_entry["StartCallTime"] >= expiration_time:
                         sso = token_entry["token"].split("sso=")[1].split(";")[0]
                         if sso in self.token_status_map and model in self.token_status_map[sso]:
                             self.token_status_map[sso][model]["isValid"] = True
                             self.token_status_map[sso][model]["invalidatedTime"] = None
                             self.token_status_map[sso][model]["totalRequestCount"] = 0
+                            self.token_status_map[sso][model]["isSuper"] = token_entry["type"] == "super"
 
                         token_entry["RequestCount"] = 0
                         token_entry["StartCallTime"] = None
@@ -525,7 +607,6 @@ class GrokApiClient:
                 },
                 json=upload_data,
                 impersonate="chrome133a",
-                verify=False,
                 **proxy_options
             )
 
@@ -571,7 +652,6 @@ class GrokApiClient:
                 },
                 json=upload_data,
                 impersonate="chrome133a",
-                verify=False,
                 **proxy_options
             )
 
@@ -586,15 +666,35 @@ class GrokApiClient:
         except Exception as error:
             logger.error(str(error), "Server")
             return ''
-
+    # def convert_system_messages(self, messages):
+    #     try:
+    #         system_prompt = []
+    #         i = 0
+    #         while i < len(messages):
+    #             if messages[i].get('role') != 'system':
+    #                 break
+
+    #             system_prompt.append(self.process_message_content(messages[i].get('content')))
+    #             i += 1
+
+    #         messages = messages[i:]
+    #         system_prompt = '\n'.join(system_prompt)
+
+    #         if not messages:
+    #             raise ValueError("没有找到用户或者AI消息")
+    #         return {"system_prompt":system_prompt,"messages":messages}
+    #     except Exception as error:
+    #         logger.error(str(error), "Server")
+    #         raise ValueError(error)
     def prepare_chat_request(self, request):
-        if ((request["model"] == 'grok-2-imageGen' or request["model"] == 'grok-3-imageGen') and
+        if ((request["model"] == 'grok-4-imageGen' or request["model"] == 'grok-3-imageGen') and
             not CONFIG["API"]["PICGO_KEY"] and not CONFIG["API"]["TUMY_KEY"] and
             request.get("stream", False)):
             raise ValueError("该模型流式输出需要配置PICGO或者TUMY图床密钥!")
 
+        # system_message, todo_messages = self.convert_system_messages(request["messages"]).values()
         todo_messages = request["messages"]
-        if request["model"] in ['grok-2-imageGen', 'grok-3-imageGen', 'grok-3-deepsearch']:
+        if request["model"] in ['grok-4-imageGen', 'grok-3-imageGen', 'grok-3-deepsearch']:
             last_message = todo_messages[-1]
             if last_message["role"] != 'user':
                 raise ValueError('此模型最后一条消息必须是用户消息!')
@@ -606,7 +706,12 @@ class GrokApiClient:
         message_length = 0
         convert_to_file = False
         last_message_content = ''
-        search = request["model"] in ['grok-2-search', 'grok-3-search']
+        search = request["model"] in ['grok-4-deepsearch', 'grok-3-search']
+        deepsearchPreset = ''
+        if request["model"] == 'grok-3-deepsearch':
+            deepsearchPreset = 'default'
+        elif request["model"] == 'grok-3-deepersearch':
+            deepsearchPreset = 'deeper'
 
         # 移除<think>标签及其内容和base64图片
         def remove_think_tags(text):
@@ -630,7 +735,6 @@ class GrokApiClient:
                 elif content["type"] == 'text':
                     return remove_think_tags(content["text"])
             return remove_think_tags(self.process_message_content(content))
-
         for current in todo_messages:
             role = 'assistant' if current["role"] == 'assistant' else 'user'
             is_last_message = current == todo_messages[-1]
@@ -694,7 +798,7 @@ class GrokApiClient:
             "imageGenerationCount": 1,
             "forceConcise": False,
             "toolOverrides": {
-                "imageGen": request["model"] in ['grok-2-imageGen', 'grok-3-imageGen'],
+                "imageGen": request["model"] in ['grok-4-imageGen', 'grok-3-imageGen'],
                 "webSearch": search,
                 "xSearch": search,
                 "xMediaSearch": search,
@@ -702,11 +806,11 @@ class GrokApiClient:
                 "xPostAnalyze": search
             },
             "enableSideBySide": True,
-            "isPreset": False,
             "sendFinalMetadata": True,
-            "customInstructions": "",
-            "deepsearchPreset": "default" if request["model"] == 'grok-3-deepsearch' else "",
-            "isReasoning": request["model"] == 'grok-3-reasoning'
+            "customPersonality": "",
+            "deepsearchPreset": deepsearchPreset,
+            "isReasoning": request["model"] == 'grok-3-reasoning',
+            "disableTextFollowUps": True
         }
 
 class MessageProcessor:
@@ -751,17 +855,14 @@ def process_model_response(response, model):
         if response.get("cachedImageGenerationResponse") and not CONFIG["IS_IMG_GEN2"]:
             result["imageUrl"] = response["cachedImageGenerationResponse"]["imageUrl"]
         return result
-
-    if model == 'grok-2':
+    if model == 'grok-3':
         result["token"] = response.get("token")
-    elif model in ['grok-2-search', 'grok-3-search']:
+    elif model in ['grok-3-search']:
         if response.get("webSearchResults") and CONFIG["ISSHOW_SEARCH_RESULTS"]:
             result["token"] = f"\r\n<think>{Utils.organize_search_results(response['webSearchResults'])}</think>\r\n"
         else:
             result["token"] = response.get("token")
-    elif model == 'grok-3':
-        result["token"] = response.get("token")
-    elif model == 'grok-3-deepsearch':
+    elif model in ['grok-3-deepsearch', 'grok-3-deepersearch','grok-4-deepsearch']:
         if response.get("messageStepId") and not CONFIG["SHOW_THINKING"]:
             return result
         if response.get("messageStepId") and not CONFIG["IS_THINKING"]:
@@ -771,7 +872,11 @@ def process_model_response(response, model):
             result["token"] = "</think>" + response.get("token", "")
             CONFIG["IS_THINKING"] = False
         elif (response.get("messageStepId") and CONFIG["IS_THINKING"] and response.get("messageTag") == "assistant") or response.get("messageTag") == "final":
-            result["token"] = response.get("token")
+            result["token"] = response.get("token","")
+        elif (CONFIG["IS_THINKING"] and response.get("token","").get("action","") == "webSearch"):
+            result["token"] = response.get("token","").get("action_input","").get("query","")            
+        elif (CONFIG["IS_THINKING"] and response.get("webSearchResults")):
+            result["token"] = Utils.organize_search_results(response['webSearchResults'])
     elif model == 'grok-3-reasoning':
         if response.get("isThinking") and not CONFIG["SHOW_THINKING"]:
             return result
@@ -785,6 +890,37 @@ def process_model_response(response, model):
         else:
             result["token"] = response.get("token")
 
+    elif model == 'grok-4':
+        if response.get("isThinking"):
+            return result
+        result["token"] = response.get("token")
+    elif model == 'grok-4-reasoning':
+        if response.get("isThinking") and not CONFIG["SHOW_THINKING"]:
+            return result
+        if response.get("isThinking") and not CONFIG["IS_THINKING"] and response.get("messageTag") == "assistant":
+            result["token"] = "<think>" + response.get("token", "")
+            CONFIG["IS_THINKING"] = True
+        elif not response.get("isThinking") and CONFIG["IS_THINKING"] and response.get("messageTag") == "final":
+            result["token"] = "</think>" + response.get("token", "")
+            CONFIG["IS_THINKING"] = False
+        else:
+            result["token"] = response.get("token")  
+    elif model in ['grok-4-deepsearch']:
+        if response.get("messageStepId") and not CONFIG["SHOW_THINKING"]:
+            return result
+        if response.get("messageStepId") and not CONFIG["IS_THINKING"] and response.get("messageTag") == "assistant":
+            result["token"] = "<think>" + response.get("token", "")
+            CONFIG["IS_THINKING"] = True
+        elif not response.get("messageStepId") and CONFIG["IS_THINKING"] and response.get("messageTag") == "final":
+            result["token"] = "</think>" + response.get("token", "")
+            CONFIG["IS_THINKING"] = False
+        elif (response.get("messageStepId") and CONFIG["IS_THINKING"] and response.get("messageTag") == "assistant") or response.get("messageTag") == "final":
+            result["token"] = response.get("token","")
+        elif (CONFIG["IS_THINKING"] and response.get("token","").get("action","") == "webSearch"):
+            result["token"] = response.get("token","").get("action_input","").get("query","")            
+        elif (CONFIG["IS_THINKING"] and response.get("webSearchResults")):
+            result["token"] = Utils.organize_search_results(response['webSearchResults'])      
+
     return result
 
 def handle_image_response(image_url):
@@ -935,6 +1071,7 @@ def handle_stream_response(response, model):
                 continue
             try:
                 line_json = json.loads(chunk.decode("utf-8").strip())
+                print(line_json)
                 if line_json.get("error"):
                     logger.error(json.dumps(line_json, indent=2), "Server")
                     yield json.dumps({"error": "RateLimitError"}) + "\n\n"
@@ -967,24 +1104,42 @@ def handle_stream_response(response, model):
     return generate()
 
 def initialization():
-    sso_array = os.getenv("SSO", "").split(',')
+    sso_array = os.environ.get("SSO", "").split(',')
+    sso_array_super = os.environ.get("SSO_SUPER", "").split(',')
+
+    combined_dict = []
+    for value in sso_array_super:
+        combined_dict.append({
+            "token": f"sso-rw={value};sso={value}", 
+            "type": "super"
+        })
+    for value in sso_array:
+        combined_dict.append({
+            "token": f"sso-rw={value};sso={value}", 
+            "type": "normal"
+        })
+    
+
     logger.info("开始加载令牌", "Server")
-    for sso in sso_array:
-        if sso:
-            token_manager.add_token(f"sso-rw={sso};sso={sso}")
+    token_manager.load_token_status()
+    for tokens in combined_dict:
+        if tokens:
+            token_manager.add_token(tokens,True)
+    token_manager.save_token_status()
 
     logger.info(f"成功加载令牌: {json.dumps(token_manager.get_all_tokens(), indent=2)}", "Server")
-    logger.info(f"令牌加载完成，共加载: {len(token_manager.get_all_tokens())}个令牌", "Server")
+    logger.info(f"令牌加载完成，共加载: {len(sso_array)+len(sso_array_super)}个令牌", "Server")
+    logger.info(f"其中共加载: {len(sso_array_super)}个super会员令牌", "Server")
 
     if CONFIG["API"]["PROXY"]:
         logger.info(f"代理已设置: {CONFIG['API']['PROXY']}", "Server")
 
-logger.info("初始化完成", "Server")
+    logger.info("初始化完成", "Server")
 
 
 app = Flask(__name__)
 app.wsgi_app = ProxyFix(app.wsgi_app)
-app.secret_key = os.getenv('FLASK_SECRET_KEY') or secrets.token_hex(16)
+app.secret_key = os.environ.get('FLASK_SECRET_KEY') or secrets.token_hex(16)
 app.json.sort_keys = False
 
 @app.route('/manager/login', methods=['GET', 'POST'])
@@ -1023,7 +1178,7 @@ def add_manager_token():
         sso = request.json.get('sso')
         if not sso:
             return jsonify({"error": "SSO token is required"}), 400
-        token_manager.add_token(f"sso-rw={sso};sso={sso}")
+        token_manager.add_token({"token":f"sso-rw={sso};sso={sso}","type":"normal"})
         return jsonify({"success": True})
     except Exception as e:
         return jsonify({"error": str(e)}), 500
@@ -1074,7 +1229,7 @@ def add_token():
 
     try:
         sso = request.json.get('sso')
-        token_manager.add_token(f"sso-rw={sso};sso={sso}")
+        token_manager.add_token({"token":f"sso-rw={sso};sso={sso}","type":"normal"})
         return jsonify(token_manager.get_token_status_map().get(sso, {})), 200
     except Exception as error:
         logger.error(str(error), "Server")
@@ -1146,7 +1301,8 @@ def chat_completions():
         retry_count = 0
         grok_client = GrokApiClient(model)
         request_payload = grok_client.prepare_chat_request(data)
-        
+
+        logger.info(json.dumps(request_payload,indent=2))
 
         while retry_count < CONFIG["RETRY"]["MAX_ATTEMPTS"]:
             retry_count += 1
@@ -1173,9 +1329,8 @@ def chat_completions():
                         **DEFAULT_HEADERS, 
                         "Cookie":CONFIG["SERVER"]['COOKIE']
                     },
-                    json=request_payload,
+                    data=json.dumps(request_payload),
                     impersonate="chrome133a",
-                    verify=False,
                     stream=True,
                     **proxy_options)
                 logger.info(CONFIG["SERVER"]['COOKIE'],"Server")
@@ -1205,6 +1360,9 @@ def chat_completions():
                     token_manager.reduce_token_request_count(model,1)#重置去除当前因为错误未成功请求的次数，确保不会因为错误未成功请求的次数导致次数上限
                     if token_manager.get_token_count_for_model(model) == 0:
                         raise ValueError(f"{model} 次数已达上限，请切换其他模型或者重新对话")
+                    print("状态码:", response.status_code)
+                    print("响应头:", response.headers)
+                    print("响应内容:", response.text)
                     raise ValueError(f"IP暂时被封无法破盾，请稍后重试或者更换ip")
                 elif response.status_code == 429:
                     response_status_code = 429