Upload app.py

app.py

@@ -8,11 +8,67 @@ import inspect
 import secrets
 from loguru import logger
 from pathlib import Path
-
+import uuid
 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
+from xStatsigIDGenerator import XStatsigIDGenerator
+import random
+import string
+
+CORE_WORDS = [
+    '__value', '_data-enctype', '_data-margin', '_style', '_transform', '_value',
+    'className', 'color', 'currentTime', 'dataset', 'disabled', 'enctype',
+    'href', 'innerHTML', 'method', 'multiple', 'name', 'naturalHeight',
+    'naturalWidth', 'offsetWidth', 'onclick', 'onerror', 'options', 'padding',
+    'paused', 'placeholder', 'position', 'scrollLeft', 'title', 'transform',
+    'type', 'width', 'zIndex', 'volume'
+]
+MODIFIERS = [
+    'InnerHTML', 'Children', 'Style', 'Options', 'Disabled', 'Onload', 'Volume', 'Alt'
+]
+
+def generate_random_part(length_min=4, length_max=8):
+    """生成一段随机乱码"""
+    length = random.randint(length_min, length_max)
+    return ''.join(random.choices('abcdefghijklmnopqrstuvwxyz0123456789', k=length))
+
+def create_error_filler():
+    """根据配方，随机组合出一个报错填充物"""
+    roll = random.random()
+
+    if roll < 0.40: # 40% 的概率: 核心词 + 随机后缀
+        word = random.choice(CORE_WORDS)
+        suffix = generate_random_part(4, 4)
+        return f"{word}_{suffix}"
+    elif roll < 0.65: # 25% 的概率: 纯核心词
+        return random.choice(CORE_WORDS)
+    elif roll < 0.85: # 20% 的概率: 纯随机乱码
+        return generate_random_part(8, 12)
+    elif roll < 0.95: # 10% 的概率: 核心词 + 数组/索引访问
+        word = random.choice(CORE_WORDS)
+        if random.random() < 0.5:
+            index = random.randint(0, 2)
+            return f"{word}[{index}]"
+        else:
+            index = generate_random_part(4, 4)
+            return f"{word}['{index}']"
+    else: # 5% 的概率: 核心词 + 修饰词
+        word1 = random.choice(CORE_WORDS).capitalize()
+        word2 = random.choice(MODIFIERS)
+        return f"{word1.lower()}{word2}"
+
+def generate_fallback_id():
+    """
+    在本地生成一个模拟的、可接受的“错误回退”x-statsig-id。
+    这是 soundai.ee 接口的本地化实现。
+    """
+    error_filler = create_error_filler()
+    error_template = "e:TypeError: Cannot read properties of null (reading '{filler}')"
+    error_message = error_template.format(filler=error_filler)
+    fallback_id = base64.b64encode(error_message.encode('utf-8')).decode('utf-8')
+    return fallback_id
 
 class Logger:
     def __init__(self, level="INFO", colorize=True, format=None):
@@ -86,16 +142,16 @@ if not DATA_DIR.exists():
     DATA_DIR.mkdir(parents=True, exist_ok=True)
 CONFIG = {
     "MODELS": {
+        'grok-4-heavy': 'grok-4-heavy',
+        'grok-4': 'grok-4',
+        'grok-4-imageGen': 'grok-4',
+        'grok-4-search': 'grok-4',
         "grok-3": "grok-3",
         "grok-3-search": "grok-3",
         "grok-3-imageGen": "grok-3",
         "grok-3-deepsearch": "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'
+        "grok-3-reasoning": "grok-3"
     },
     "API": {
         "IS_TEMP_CONVERSATION": os.environ.get("IS_TEMP_CONVERSATION", "true").lower() == "true",
@@ -122,82 +178,204 @@ CONFIG = {
         "MAX_ATTEMPTS": 2
     },
     "TOKEN_STATUS_FILE": str(DATA_DIR / "token_status.json"),
-    "SHOW_THINKING": os.environ.get("SHOW_THINKING").lower() == "true",
+    "SHOW_THINKING": os.environ.get("SHOW_THINKING") == "true",
     "IS_THINKING": False,
     "IS_IMG_GEN": False,
     "IS_IMG_GEN2": False,
-    "ISSHOW_SEARCH_RESULTS": os.environ.get("ISSHOW_SEARCH_RESULTS", "true").lower() == "true",
-    "IS_SUPER_GROK": os.environ.get("IS_SUPER_GROK", "false").lower() == "true"
+    "ISSHOW_SEARCH_RESULTS": os.environ.get("ISSHOW_SEARCH_RESULTS", "true").lower() == "true"
 }
 
+def generate_statsig_id_fallback():
+    """
+    使用自主生成方法作为备用方案生成 x_statsig_id
+    """
+    try:
+        generator = XStatsigIDGenerator()
+        x_statsig_id = generator.generate_x_statsig_id()
+        logger.info("使用自主生成方法成功生成 x_statsig_id", "StatsigGenerator")
+        return x_statsig_id
+    except Exception as e:
+        logger.error(f"自主生成 x_statsig_id 失败: {e}", "StatsigGenerator")
+        # 如果自主生成也失败，返回一个默认值
+        return "fallback-statsig-id-" + str(uuid.uuid4())
+
+def get_x_statsig_id_primary():
+    """
+    主要策略：优先使用自主生成方法生成 x_statsig_id
+    """
+    try:
+        logger.info("使用主要策略：自主生成 x_statsig_id", "StatsigGenerator")
+        generator = XStatsigIDGenerator()
+        x_statsig_id = generator.generate_x_statsig_id()
+        logger.info("主要策略成功：自主生成 x_statsig_id 完成", "StatsigGenerator")
+        return {
+            'success': True,
+            'x_statsig_id': x_statsig_id,
+            'method': 'self_generated'
+        }
+    except Exception as e:
+        logger.error(f"主要策略失败：自主生成 x_statsig_id 错误: {e}", "StatsigGenerator")
+        return {
+            'success': False,
+            'error': str(e),
+            'method': 'self_generated'
+        }
 
-DEFAULT_HEADERS = {
-    'Accept': '*/*',
-    'Accept-Language': 'zh-CN,zh;q=0.9',
-    'Accept-Encoding': 'gzip, deflate, br, zstd',
-    'Content-Type': 'text/plain;charset=UTF-8',
-    'Connection': 'keep-alive',
-    'Origin': 'https://grok.com',
-    'Priority': 'u=1, i',
-    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
-    'Sec-Ch-Ua': '"Not(A:Brand";v="99", "Google Chrome";v="133", "Chromium";v="133"',
-    'Sec-Ch-Ua-Mobile': '?0',
-    'Sec-Ch-Ua-Platform': '"macOS"',
-    'Sec-Fetch-Dest': 'empty',
-    'Sec-Fetch-Mode': 'cors',
-    'Sec-Fetch-Site': 'same-origin',
-    'Baggage': 'sentry-public_key=b311e0f2690c81f25e2c4cf6d4f7ce1c',
-    'x-statsig-id': 'ZTpUeXBlRXJyb3I6IENhbm5vdCByZWFkIHByb3BlcnRpZXMgb2YgdW5kZWZpbmVkIChyZWFkaW5nICdjaGlsZE5vZGVzJyk='
-}
+def get_x_statsig_id_fallback():
+    """
+    备用策略：使用本地生成的“错误回退ID”，替代原来的网络请求。
+    """
+    try:
+        logger.info("使用备用策略：本地生成错误回退 ID", "StatsigLocal")
+        fallback_id = generate_fallback_id()
+        
+        if fallback_id:
+            logger.info("备用策略成功：本地生成错误回退 ID 完成", "StatsigLocal")
+            return {
+                'success': True,
+                'x_statsig_id': fallback_id,
+                'method': 'local_fallback_generator'
+            }
+        else:
+            # 理论上我们自己的代码不会失败，但还是保留错误处理
+            logger.error("备用策略失败：本地生成ID时出错", "StatsigLocal")
+            return {
+                'success': False,
+                'error': '本地生成ID失败',
+                'method': 'local_fallback_generator'
+            }
+
+    except Exception as e:
+        logger.error(f"备用策略异常：{e}", "StatsigLocal")
+        return {
+            'success': False,
+            'error': str(e),
+            'method': 'local_fallback_generator'
+        }
+
+def get_x_statsig_id():
+    """
+    获取 x_statsig_id，优先使用自主生成方法，失败时使用 PHP 接口
+    """
+    # 主要策略：自主生成
+    primary_result = get_x_statsig_id_primary()
+
+    if primary_result['success']:
+        return primary_result['x_statsig_id']
+
+    # 备用策略：PHP 接口
+    logger.warning("主要策略失败，切换到备用策略", "StatsigStrategy")
+    fallback_result = get_x_statsig_id_fallback()
+
+    if fallback_result['success']:
+        return fallback_result['x_statsig_id']
+
+    # 所有策略都失败，返回默认值
+    logger.error("所有策略都失败，使用默认 x_statsig_id", "StatsigStrategy")
+    return "fallback-statsig-id-" + str(uuid.uuid4())
+
+# 初始化 x_statsig_id（在应用启动时获取一次）
+_cached_x_statsig_id = None
+_cached_x_statsig_id_method = None
+
+def get_cached_x_statsig_id():
+    """
+    获取缓存的 x_statsig_id，如果没有缓存则重新获取
+    """
+    global _cached_x_statsig_id, _cached_x_statsig_id_method
+    if _cached_x_statsig_id is None:
+        _cached_x_statsig_id = get_x_statsig_id()
+        _cached_x_statsig_id_method = 'initial'
+    return _cached_x_statsig_id
+
+def refresh_x_statsig_id_with_fallback():
+    """
+    强制刷新 x_statsig_id，使用备用策略（PHP 接口）
+    """
+    global _cached_x_statsig_id, _cached_x_statsig_id_method
+
+    logger.info("强制刷新 x_statsig_id，使用备用策略", "StatsigStrategy")
+    fallback_result = get_x_statsig_id_fallback()
+
+    if fallback_result['success']:
+        _cached_x_statsig_id = fallback_result['x_statsig_id']
+        _cached_x_statsig_id_method = 'php_interface'
+        logger.info("成功使用备用策略刷新 x_statsig_id", "StatsigStrategy")
+        return _cached_x_statsig_id
+    else:
+        logger.error("备用策略也失败，保持原有 x_statsig_id", "StatsigStrategy")
+        return _cached_x_statsig_id
+
+def get_default_headers(force_refresh_statsig=False):
+    """
+    动态生成默认请求头，确保 X-Statsig-Id 总是可用
+
+    Args:
+        force_refresh_statsig: 是否强制刷新 x_statsig_id（使用备用策略）
+    """
+    if force_refresh_statsig:
+        statsig_id = refresh_x_statsig_id_with_fallback()
+    else:
+        statsig_id = get_cached_x_statsig_id()
+
+    return {
+        'Accept': '*/*',
+        'Accept-Language': 'zh-CN,zh;q=0.9',
+        'Accept-Encoding': 'gzip, deflate, br, zstd',
+        'Content-Type': 'text/plain;charset=UTF-8',
+        'Connection': 'keep-alive',
+        'Origin': 'https://grok.com',
+        'Priority': 'u=1, i',
+        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36',
+        'Sec-Ch-Ua': '"Not(A:Brand";v="99", "Google Chrome";v="133", "Chromium";v="133"',
+        'Sec-Ch-Ua-Mobile': '?0',
+        'Sec-Ch-Ua-Platform': '"macOS"',
+        'Sec-Fetch-Dest': 'empty',
+        'Sec-Fetch-Mode': 'cors',
+        'Sec-Fetch-Site': 'same-origin',
+        'X-Statsig-Id': statsig_id,
+        'X-Xai-Request-Id': str(uuid.uuid4()),
+        'Baggage': 'sentry-public_key=b311e0f2690c81f25e2c4cf6d4f7ce1c'
+    }
+
+# 为了向后兼容，保留 DEFAULT_HEADERS 变量
+DEFAULT_HEADERS = get_default_headers()
 
 class AuthTokenManager:
     def __init__(self):
         self.token_model_map = {}
         self.expired_tokens = set()
         self.token_status_map = {}
-        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 = {
+            "grok-4": {
+                "RequestFrequency": 20,
+                "ExpirationTime": 24 * 60 * 60 * 1000  # 24小时
+            },
+            "grok-3": {
+                "RequestFrequency": 30,
+                "ExpirationTime": 2 * 60 * 60 * 1000  # 2小时
+            },
+            "grok-3-deepsearch": {
+                "RequestFrequency": 30,
+                "ExpirationTime": 24 * 60 * 60 * 1000  # 24小时
+            },
+            "grok-3-deepersearch": {
+                "RequestFrequency": 30,
+                "ExpirationTime": 24 * 60 * 60 * 1000  # 24小时
+            },
+            "grok-3-reasoning": {
+                "RequestFrequency": 30,
+                "ExpirationTime": 24 * 60 * 60 * 1000  # 24小时
+            },
+            "grok-4-heavy": {
+                "RequestFrequency": 20,
+                "ExpirationTime": 24 * 60 * 60 * 1000  # 24小时
             }
-        self.model_config = self.model_normal_config
+        }
         self.token_reset_switch = False
         self.token_reset_timer = None
+        self.load_token_status() # 加载令牌状态
     def save_token_status(self):
         try:        
             with open(CONFIG["TOKEN_STATUS_FILE"], 'w', encoding='utf-8') as f:
@@ -215,67 +393,47 @@ class AuthTokenManager:
                 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,isinitialization=False):
+        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"] == tokenSso), None)
+            existing_token_entry = next((entry for entry in self.token_model_map[model] if entry["token"] == token), None)
 
             if not existing_token_entry:
                 self.token_model_map[model].append({
-                    "token": tokenSso,
-                    "MaxRequestCount": self.model_config[model]["RequestFrequency"],
+                    "token": token,
                     "RequestCount": 0,
                     "AddedTime": int(time.time() * 1000),
-                    "StartCallTime": None,
-                    "type": tokenType
+                    "StartCallTime": None
                 })
 
                 if model not in self.token_status_map[sso]:
                     self.token_status_map[sso][model] = {
                         "isValid": True,
                         "invalidatedTime": None,
-                        "totalRequestCount": 0,
-                        "isSuper":tokenType == "super"
+                        "totalRequestCount": 0
                     }
         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": tokenSso,
-            "MaxRequestCount": self.model_config[model]["RequestFrequency"],
+            "token": token,
             "RequestCount": 0,
             "AddedTime": int(time.time() * 1000),
-            "StartCallTime": None,
-            "type": tokenType
+            "StartCallTime": None
         }] for model in models}
 
-        sso = tokenSso.split("sso=")[1].split(";")[0]
+        sso = token.split("sso=")[1].split(";")[0]
         self.token_status_map[sso] = {model: {
             "isValid": True,
             "invalidatedTime": None,
-            "totalRequestCount": 0,
-            "isSuper":tokenType == "super"
+            "totalRequestCount": 0
         } for model in models}
 
     def delete_token(self, token):
@@ -334,15 +492,10 @@ 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)
 
@@ -352,21 +505,18 @@ class AuthTokenManager:
 
             token_entry["RequestCount"] += 1
 
-            if token_entry["RequestCount"] > token_entry["MaxRequestCount"]:
+            if token_entry["RequestCount"] > self.model_config[normalized_model]["RequestFrequency"]:
                 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"]
@@ -388,8 +538,7 @@ class AuthTokenManager:
             self.expired_tokens.add((
                 removed_token_entry["token"],
                 normalized_model,
-                int(time.time() * 1000),
-                removed_token_entry["type"]
+                int(time.time() * 1000)
             ))
 
             if not self.token_reset_switch:
@@ -406,7 +555,7 @@ class AuthTokenManager:
         return list(self.expired_tokens)
 
     def normalize_model_name(self, model):
-        if model.startswith('grok-') and not any(keyword in model for keyword in ['deepsearch','deepersearch','reasoning']):
+        if model.startswith('grok-') and 'deepsearch' not in model and 'reasoning' not in model:
             return '-'.join(model.split('-')[:2])
         return model
 
@@ -419,8 +568,8 @@ class AuthTokenManager:
 
         for model in self.model_config.keys():
             model_tokens = self.token_model_map.get(model, [])
-            
-            model_request_frequency = sum(token_entry.get("MaxRequestCount", 0) for token_entry in model_tokens)
+            model_request_frequency = self.model_config[model]["RequestFrequency"]
+
             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
@@ -436,13 +585,10 @@ 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 ,type = token_info
-                if type == "super":
-                    model_config = self.model_super_config
-                expiration_time = model_config[model]["ExpirationTime"]
+                token, model, expired_time = token_info
+                expiration_time = self.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, [])):
@@ -451,11 +597,9 @@ class AuthTokenManager:
 
                         self.token_model_map[model].append({
                             "token": token,
-                            "MaxRequestCount": model_config[model]["RequestFrequency"],
                             "RequestCount": 0,
                             "AddedTime": now,
-                            "StartCallTime": None,
-                            "type": type
+                            "StartCallTime": None
                         })
 
                     sso = token.split("sso=")[1].split(";")[0]
@@ -463,13 +607,12 @@ 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 model_config.keys():
+            for model in self.model_config.keys():
                 if model not in self.token_model_map:
                     continue
 
@@ -477,14 +620,13 @@ class AuthTokenManager:
                     if not token_entry.get("StartCallTime"):
                         continue
 
-                    expiration_time = model_config[model]["ExpirationTime"]
+                    expiration_time = self.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
@@ -518,6 +660,73 @@ class AuthTokenManager:
     def get_token_status_map(self):
         return self.token_status_map
 
+def smart_grok_request_with_fallback(request_func, *args, **kwargs):
+    """
+    智能 Grok API 请求函数，支持 x_statsig_id 降级重试机制
+
+    Args:
+        request_func: 要执行的请求函数
+        *args: 请求函数的位置参数
+        **kwargs: 请求函数的关键字参数
+
+    Returns:
+        请求结果
+    """
+    max_retries = 2  # 最多重试2次（主要策略1次 + 备用策略1次）
+
+    for attempt in range(max_retries):
+        try:
+            # 第一次尝试使用当前的 x_statsig_id（可能是自主生成的）
+            if attempt == 0:
+                logger.info("使用主要策略发起 Grok API 请求", "SmartRequest")
+                response = request_func(*args, **kwargs)
+            else:
+                # 第二次尝试：强制使用备用策略（PHP 接口）刷新 x_statsig_id
+                logger.warning("主要策略失败，使用备用策略重新发起 Grok API 请求", "SmartRequest")
+
+                # 更新 kwargs 中的 headers，强制刷新 x_statsig_id
+                if 'headers' in kwargs:
+                    kwargs['headers'].update(get_default_headers(force_refresh_statsig=True))
+                else:
+                    kwargs['headers'] = get_default_headers(force_refresh_statsig=True)
+
+                response = request_func(*args, **kwargs)
+
+            # 检查响应状态码
+            if hasattr(response, 'status_code'):
+                status_code = response.status_code
+
+                # 如果是成功状态码，直���返回
+                if 200 <= status_code < 300:
+                    if attempt > 0:
+                        logger.info(f"备用策略成功：Grok API 请求成功 (状态码: {status_code})", "SmartRequest")
+                    else:
+                        logger.info(f"主要策略成功：Grok API 请求成功 (状态码: {status_code})", "SmartRequest")
+                    return response
+
+                # 如果是 4xx 或 5xx 错误，且还有重试机会，继续重试
+                elif (400 <= status_code < 600) and attempt < max_retries - 1:
+                    logger.warning(f"Grok API 请求失败 (状态码: {status_code})，尝试使用备用策略", "SmartRequest")
+                    continue
+                else:
+                    # 最后一次重试也失败了
+                    logger.error(f"所有策略都失败：Grok API 请求失败 (状态码: {status_code})", "SmartRequest")
+                    return response
+            else:
+                # 没有 status_code 属性，直接返回响应
+                return response
+
+        except Exception as e:
+            if attempt < max_retries - 1:
+                logger.warning(f"Grok API 请求异常: {e}，尝试使用备用策略", "SmartRequest")
+                continue
+            else:
+                logger.error(f"所有策略都失败：Grok API 请求异常: {e}", "SmartRequest")
+                raise
+
+    # 理论上不会到达这里
+    return None
+
 class Utils:
     @staticmethod
     def organize_search_results(search_results):
@@ -532,11 +741,43 @@ class Utils:
             url = result.get('url', '#')
             preview = result.get('preview', '无预览内容')
 
-            formatted_result = f"\r\n<details><summary>资料[{index}]: {title}</summary>\r\n{preview}\r\n\n[Link]({url})\r\n</details>"
+            formatted_result = f"\r\n<details><summary>资料[{index}]: {title}</summary>\r\n{preview}\r\n\n[{title}]({url})\r\n</details>\n"
             formatted_results.append(formatted_result)
 
         return '\n\n'.join(formatted_results)
 
+
+
+    @staticmethod
+    def safe_filter_grok_tags(text):
+        """
+        只移除 <xai:tool_usage_card> 标签
+        """
+        if not text or not isinstance(text, str):
+            return text
+
+        start_tag, end_tag = ("<xai:tool_usage_card>", "</xai:tool_usage_card>")
+    
+        if start_tag in text:
+            original_text = text
+            while True:
+                end_index = text.rfind(end_tag)
+                if end_index == -1:
+                    break
+            
+                start_index = text.rfind(start_tag, 0, end_index)
+                if start_index == -1:
+                    break
+            
+                text = text[:start_index] + text[end_index + len(end_tag):]
+            
+            if text != original_text:
+                return text.strip()
+            else:
+                return text
+        else:
+            return text
+
     @staticmethod
     def create_auth_headers(model, is_return=False):
         return token_manager.get_next_token_for_model(model, is_return)
@@ -597,16 +838,24 @@ class GrokApiClient:
             }
 
             logger.info("发送文字文件请求", "Server")
-            cookie = f"{Utils.create_auth_headers(model, True)};{CONFIG['SERVER']['CF_CLEARANCE']}" 
+            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",
+
+            # 使用智能重试机制发起文件上传请求
+            def make_upload_request(**request_kwargs):
+                return curl_requests.post(
+                    "https://grok.com/rest/app-chat/upload-file",
+                    json=upload_data,
+                    impersonate="chrome133a",
+                    **request_kwargs
+                )
+
+            response = smart_grok_request_with_fallback(
+                make_upload_request,
                 headers={
-                    **DEFAULT_HEADERS,
-                    "Cookie":cookie
+                    **get_default_headers(),
+                    "Cookie": cookie
                 },
-                json=upload_data,
-                impersonate="chrome133a",
                 **proxy_options
             )
 
@@ -644,14 +893,22 @@ class GrokApiClient:
             logger.info("发送图片请求", "Server")
 
             proxy_options = Utils.get_proxy_options()
-            response = curl_requests.post(
-                url,
+
+            # 使用智能重试机制发起图片上传请求
+            def make_image_upload_request(**request_kwargs):
+                return curl_requests.post(
+                    url,
+                    json=upload_data,
+                    impersonate="chrome133a",
+                    **request_kwargs
+                )
+
+            response = smart_grok_request_with_fallback(
+                make_image_upload_request,
                 headers={
-                    **DEFAULT_HEADERS,
-                    "Cookie":CONFIG["SERVER"]['COOKIE']
+                    **get_default_headers(),
+                    "Cookie": CONFIG["SERVER"]['COOKIE']
                 },
-                json=upload_data,
-                impersonate="chrome133a",
                 **proxy_options
             )
 
@@ -706,14 +963,13 @@ class GrokApiClient:
         message_length = 0
         convert_to_file = False
         last_message_content = ''
-        search = request["model"] in ['grok-4-deepsearch', 'grok-3-search']
+        search = request["model"] in ['grok-4-search', '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):
             import re
             text = re.sub(r'<think>[\s\S]*?<\/think>', '', text).strip()
@@ -849,80 +1105,72 @@ class MessageProcessor:
         }
 
 def process_model_response(response, model):
-    result = {"token": None, "imageUrl": None}
+    """
+    处理来自 Grok API 的流式响应块。
+    此版本精准修复了非 Agent 模型（如 grok-3）会重复输出内容的问题，
+    方法是在接收到最终 modelResponse 块时将其忽略。
+    所有针对 Agent 模型的处理逻辑保持原始状态不变。
+    """
+    result = {"token": None, "type": None}
+    AGENT_MODELS = ['grok-4-heavy', 'grok-4', 'grok-3-deepersearch', 'grok-3-deepsearch']
 
     if CONFIG["IS_IMG_GEN"]:
         if response.get("cachedImageGenerationResponse") and not CONFIG["IS_IMG_GEN2"]:
             result["imageUrl"] = response["cachedImageGenerationResponse"]["imageUrl"]
+            result["type"] = 'image_url'
         return result
-    if model == 'grok-3':
-        result["token"] = response.get("token")
-    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 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"]:
-            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'])
-    elif model == 'grok-3-reasoning':
-        if response.get("isThinking") and not CONFIG["SHOW_THINKING"]:
-            return result
 
-        if response.get("isThinking") and not CONFIG["IS_THINKING"]:
-            result["token"] = "<think>" + response.get("token", "")
-            CONFIG["IS_THINKING"] = True
-        elif not response.get("isThinking") and CONFIG["IS_THINKING"]:
-            result["token"] = "</think>" + response.get("token", "")
-            CONFIG["IS_THINKING"] = False
-        else:
-            result["token"] = response.get("token")
+    message_tag = response.get("messageTag")
+    token = response.get("token")
+    
+    if message_tag == 'heartbeat':
+        result["type"] = 'heartbeat'
+        return result
 
-    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"]:
+    if model not in AGENT_MODELS and response.get("modelResponse"):
+        return result
+
+    if response.get("modelResponse") and isinstance(response["modelResponse"], dict):
+        final_message = response["modelResponse"].get("message")
+        if final_message:
+            result["token"] = Utils.safe_filter_grok_tags(final_message)
+            result["type"] = 'content'
+        return result
+
+    if model in AGENT_MODELS:
+        THINKING_TAGS = {'header', 'summary', 'raw_function_result', 'citedWebSearchResults'}
+        if message_tag in THINKING_TAGS:
+            content_to_filter = None
+            if token: content_to_filter = token
+            elif response.get('webSearchResults') and CONFIG["ISSHOW_SEARCH_RESULTS"]:
+                content_to_filter = Utils.organize_search_results(response['webSearchResults'])
+            
+            if content_to_filter:
+                filtered_content = Utils.safe_filter_grok_tags(content_to_filter)
+                if filtered_content:
+                    result["token"] = filtered_content
+                    result["type"] = '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"]:
+
+    if model in AGENT_MODELS:
+        is_verbose_thinking = (response.get("isThinking") or response.get("messageStepId")) and message_tag not in {'header', 'summary'}
+        if is_verbose_thinking:
+            if not CONFIG["SHOW_THINKING"]:
+                result["type"] = 'heartbeat'
+                return result
+            elif token:
+                filtered_token = Utils.safe_filter_grok_tags(token)
+                if filtered_token:
+                    result["token"] = filtered_token
+                    result["type"] = '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'])      
+    
+    if model not in AGENT_MODELS and token:
+        result["token"] = Utils.safe_filter_grok_tags(token)
+        result["type"] = 'content'
+        return result
 
     return result
-
 def handle_image_response(image_url):
     max_retries = 2
     retry_count = 0
@@ -931,13 +1179,21 @@ def handle_image_response(image_url):
     while retry_count < max_retries:
         try:
             proxy_options = Utils.get_proxy_options()
-            image_base64_response = curl_requests.get(
-                f"https://assets.grok.com/{image_url}",
+
+            # 使用智能重试机制发起图片下载请求
+            def make_image_download_request(**request_kwargs):
+                return curl_requests.get(
+                    f"https://assets.grok.com/{image_url}",
+                    impersonate="chrome133a",
+                    **request_kwargs
+                )
+
+            image_base64_response = smart_grok_request_with_fallback(
+                make_image_download_request,
                 headers={
-                    **DEFAULT_HEADERS,
-                    "Cookie":CONFIG["SERVER"]['COOKIE']
+                    **get_default_headers(),
+                    "Cookie": CONFIG["SERVER"]['COOKIE']
                 },
-                impersonate="chrome133a",
                 **proxy_options
             )
 
@@ -1057,84 +1313,137 @@ def handle_non_stream_response(response, model):
     except Exception as error:
         logger.error(str(error), "Server")
         raise
-def handle_stream_response(response, model):
-    def generate():
-        logger.info("开始处理流式响应", "Server")
-
-        stream = response.iter_lines()
-        CONFIG["IS_THINKING"] = False
-        CONFIG["IS_IMG_GEN"] = False
-        CONFIG["IS_IMG_GEN2"] = False
 
-        for chunk in stream:
-            if not chunk:
-                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"
-                    return
+def handle_stream_response(response, model):
+    
+    AGENT_MODELS = ['grok-4-heavy', 'grok-4', 'grok-3-deepersearch', 'grok-3-deepsearch']
 
-                response_data = line_json.get("result", {}).get("response")
-                if not response_data:
+    # ================= 分支 A: Agent 模型的专用处理逻辑 =================
+    if model in AGENT_MODELS:
+        def generate_agent():
+            logger.info(f"使用 Agent 模型专用逻辑处理: {model}", "Server")
+            stream = response.iter_lines()
+            
+            is_in_think_block = False
+            final_answer_started = False
+
+            # Agent 模型的内部辅助函数
+            def yield_agent_content(content_to_yield, content_type='content'):
+                nonlocal is_in_think_block
+                is_thinking_content = content_type == 'thinking'
+
+                if is_thinking_content and not is_in_think_block:
+                    is_in_think_block = True
+                    payload = MessageProcessor.create_chat_response('<think>\n', model, True)
+                    yield f"data: {json.dumps(payload)}\n\n"
+                
+                elif not is_thinking_content and is_in_think_block:
+                    is_in_think_block = False
+                    payload = MessageProcessor.create_chat_response('</think>\n\n', model, True)
+                    json_payload = json.dumps(payload)
+                    yield f"data: {json_payload}\n\n"
+
+                if content_to_yield:
+                    payload = MessageProcessor.create_chat_response(content_to_yield, model, True)
+                    yield f"data: {json.dumps(payload)}\n\n"
+
+            for chunk in stream:
+                if not chunk: continue
+                try:
+                    line_json = json.loads(chunk.decode("utf-8").strip())
+                    if line_json.get("error"): continue
+
+                    response_data = line_json.get("result", {}).get("response")
+                    if not response_data: continue
+                    
+                    if response_data.get("modelResponse") and isinstance(response_data["modelResponse"], dict):
+                        final_answer_started = True
+                        for part in yield_agent_content(None, content_type='content'):
+                            yield part
+                        
+                        final_message = response_data["modelResponse"].get("message")
+                        if final_message:
+                            clean_message = Utils.safe_filter_grok_tags(final_message)
+                            payload = MessageProcessor.create_chat_response(clean_message, model, True)
+                            yield f"data: {json.dumps(payload)}\n\n"
+                        break
+
+                    result = process_model_response(response_data, model)
+                    if result.get("type") == 'heartbeat':
+                        yield ":ping\n\n"
+                    elif result.get("type") == 'thinking':
+                        for part in yield_agent_content(result.get("token"), content_type='thinking'):
+                            yield part
+
+                except Exception as e:
+                    logger.error(f"处理 Agent 流时出错: {str(e)}", "Server")
                     continue
+            
+            if is_in_think_block and not final_answer_started:
+                payload = MessageProcessor.create_chat_response('</think>\n\n', model, True)
+                json_payload = json.dumps(payload)
+                yield f"data: {json_payload}\n\n"
 
-                if response_data.get("doImgGen") or response_data.get("imageAttachmentInfo"):
-                    CONFIG["IS_IMG_GEN"] = True
-
-                result = process_model_response(response_data, model)
-
-                if result["token"]:
-                    yield f"data: {json.dumps(MessageProcessor.create_chat_response(result['token'], model, True))}\n\n"
-
-                if result["imageUrl"]:
-                    CONFIG["IS_IMG_GEN2"] = True
-                    image_data = handle_image_response(result["imageUrl"])
-                    yield f"data: {json.dumps(MessageProcessor.create_chat_response(image_data, model, True))}\n\n"
+            yield "data: [DONE]\n\n"
+        return generate_agent()
 
-            except json.JSONDecodeError:
-                continue
-            except Exception as e:
-                logger.error(f"处理流式响应行时出错: {str(e)}", "Server")
-                continue
 
-        yield "data: [DONE]\n\n"
-    return generate()
+    # ================= 分支 B: 标准模型的逻辑 =================
+    else:
+        def generate_standard_fixed():
+            logger.info(f"使用标准模型逻辑处理 (精准模仿作者图片处理): {model}", "Server")
+            stream = response.iter_lines()
+
+            CONFIG["IS_IMG_GEN"] = False
+            CONFIG["IS_IMG_GEN2"] = False
+
+            for chunk in stream:
+                if not chunk: continue
+                try:
+                    line_json = json.loads(chunk.decode("utf-8").strip())
+                    if line_json.get("error"): continue
+
+                    response_data = line_json.get("result", {}).get("response")
+                    if not response_data: continue
+                    
+                    if response_data.get("doImgGen") or response_data.get("imageAttachmentInfo"):
+                        CONFIG["IS_IMG_GEN"] = True
+                    
+                    result = process_model_response(response_data, model)
+
+                    if result.get("token"):
+                        payload = MessageProcessor.create_chat_response(result["token"], model, True)
+                        yield f"data: {json.dumps(payload)}\n\n"
+
+                    if result.get("imageUrl"):
+                        CONFIG["IS_IMG_GEN2"] = True
+                        image_data = handle_image_response(result["imageUrl"])
+                        payload = MessageProcessor.create_chat_response(image_data, model, True)
+                        yield f"data: {json.dumps(payload)}\n\n"
+                        
+                except Exception as e:
+                    logger.error(f"处理标准流时出错: {str(e)}", "Server")
+                    continue
 
+            yield "data: [DONE]\n\n"
+        
+        return generate_standard_fixed()
 def initialization():
     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")
     token_manager.load_token_status()
-    for tokens in combined_dict:
-        if tokens:
-            token_manager.add_token(tokens,True)
+    for sso in sso_array:
+        if sso:
+            token_manager.add_token(f"sso-rw={sso};sso={sso}",True)
     token_manager.save_token_status()
 
     logger.info(f"成功加载令牌: {json.dumps(token_manager.get_all_tokens(), indent=2)}", "Server")
-    logger.info(f"令牌加载完成，共加载: {len(sso_array)+len(sso_array_super)}个令牌", "Server")
-    logger.info(f"其中共加载: {len(sso_array_super)}个super会员令牌", "Server")
+    logger.info(f"令牌加载完成，共加载: {len(token_manager.get_all_tokens())}个令牌", "Server")
 
     if CONFIG["API"]["PROXY"]:
         logger.info(f"代理已设置: {CONFIG['API']['PROXY']}", "Server")
 
-    logger.info("初始化完成", "Server")
+logger.info("初始化完成", "Server")
 
 
 app = Flask(__name__)
@@ -1178,7 +1487,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({"token":f"sso-rw={sso};sso={sso}","type":"normal"})
+        token_manager.add_token(f"sso-rw={sso};sso={sso}")
         return jsonify({"success": True})
     except Exception as e:
         return jsonify({"error": str(e)}), 500
@@ -1229,7 +1538,7 @@ def add_token():
 
     try:
         sso = request.json.get('sso')
-        token_manager.add_token({"token":f"sso-rw={sso};sso={sso}","type":"normal"})
+        token_manager.add_token(f"sso-rw={sso};sso={sso}")
         return jsonify(token_manager.get_token_status_map().get(sso, {})), 200
     except Exception as error:
         logger.error(str(error), "Server")
@@ -1301,7 +1610,6 @@ 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"]:
@@ -1323,16 +1631,25 @@ def chat_completions():
             logger.info(json.dumps(request_payload,indent=2),"Server")
             try:
                 proxy_options = Utils.get_proxy_options()
-                response = curl_requests.post(
-                    f"{CONFIG['API']['BASE_URL']}/rest/app-chat/conversations/new",
+
+                # 使用智能重试机制发起请求
+                def make_grok_request(**request_kwargs):
+                    return curl_requests.post(
+                        f"{CONFIG['API']['BASE_URL']}/rest/app-chat/conversations/new",
+                        data=json.dumps(request_payload),
+                        impersonate="chrome133a",
+                        stream=True,
+                        **request_kwargs
+                    )
+
+                response = smart_grok_request_with_fallback(
+                    make_grok_request,
                     headers={
-                        **DEFAULT_HEADERS, 
-                        "Cookie":CONFIG["SERVER"]['COOKIE']
+                        **get_default_headers(),
+                        "Cookie": CONFIG["SERVER"]['COOKIE']
                     },
-                    data=json.dumps(request_payload),
-                    impersonate="chrome133a",
-                    stream=True,
-                    **proxy_options)
+                    **proxy_options
+                )
                 logger.info(CONFIG["SERVER"]['COOKIE'],"Server")
                 if response.status_code == 200:
                     response_status_code = 200
@@ -1416,4 +1733,4 @@ if __name__ == '__main__':
         host='0.0.0.0',
         port=CONFIG["SERVER"]["PORT"],
         debug=False
-    )
+            )