Upload 2 files

Dockerfile

@@ -1,32 +1,31 @@
-FROM node:18-slim
-
-# 安装 Chrome 依赖
-RUN apt-get update && apt-get install -y \
-    wget \
-    gnupg \
-    ca-certificates \
-    procps \
-    chromium \
-    chromium-sandbox
-
-# 设置工作目录
-WORKDIR /app
-
-# 复制 package.json 和 package-lock.json
-COPY package*.json ./
-
-# 安装依赖
-RUN npm install
-
-# 复制源代码
-COPY . .
-
-# 设置环境变量
-ENV CHROME_PATH=/usr/bin/chromium
-ENV PORT=7860
-
-# 暴露端口
-EXPOSE 7860
-
-# 启动应用
+FROM node:18-slim
+
+# 安装 Chrome 依赖
+RUN apt-get update && apt-get install -y \
+    wget \
+    gnupg \
+    ca-certificates \
+    procps \
+    chromium \
+    chromium-sandbox
+
+# 设置工作目录
+WORKDIR /app
+
+# 复制 package.json 和 package-lock.json
+COPY package*.json ./
+
+# 安装依赖
+RUN npm install
+
+# 复制源代码
+COPY . .
+
+# 设置环境变量
+ENV PORT=7860
+
+# 暴露端口
+EXPOSE 7860
+
+# 启动应用
 CMD ["npm", "start"] 

index.js

@@ -17,16 +17,21 @@ const CONFIG = {
         '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"
     },
     API: {
+        IS_TEMP_GROK2: process.env.IS_TEMP_GROK2 == undefined ? true : process.env.IS_TEMP_GROK2 == 'true',
+        GROK2_CONCURRENCY_LEVEL: process.env.GROK2_CONCURRENCY_LEVEL || 4,
+        IS_CUSTOM_SSO: process.env.IS_CUSTOM_SSO == undefined ? false : process.env.IS_CUSTOM_SSO == 'true',
         BASE_URL: "https://grok.com",
         API_KEY: process.env.API_KEY || "sk-123456",
         SIGNATURE_COOKIE: null,
         TEMP_COOKIE: null,
-        PICGO_KEY: process.env.PICGO_KEY || null //想要流式生图的话需要填入这个PICGO图床的key
+        PICGO_KEY: process.env.PICGO_KEY || null, //想要流式生图的话需要填入这个PICGO图床的key
+        TUMY_KEY: process.env.TUMY_KEY || null //想要流式生图的话需要填入这个TUMY图床的key 两个图床二选一，默认使用PICGO
     },
     SERVER: {
         PORT: process.env.PORT || 3000,
@@ -35,15 +40,17 @@ const CONFIG = {
     RETRY: {
         MAX_ATTEMPTS: 2//重试次数
     },
-    SHOW_THINKING:process.env.SHOW_THINKING === 'true',//显示思考过程
+    SHOW_THINKING: process.env.SHOW_THINKING === 'true',
     IS_THINKING: false,
     IS_IMG_GEN: false,
     IS_IMG_GEN2: false,
     SSO_INDEX: 0,//sso的索引
-    ISSHOW_SEARCH_RESULTS: process.env.ISSHOW_SEARCH_RESULTS === 'true',//是否显示搜索结果,默认关闭
-    CHROME_PATH: process.env.CHROME_PATH || "/usr/bin/chromium"//chrome路径
+    TEMP_COOKIE_INDEX: 0,//临时cookie的下标
+    ISSHOW_SEARCH_RESULTS: process.env.ISSHOW_SEARCH_RESULTS == undefined ? true : process.env.ISSHOW_SEARCH_RESULTS == 'true',//是否显示搜索结果
+    CHROME_PATH: process.env.CHROME_PATH || null
 };
 puppeteer.use(StealthPlugin())
+
 // 请求头配置
 const DEFAULT_HEADERS = {
     'accept': '*/*',
@@ -65,13 +72,30 @@ const DEFAULT_HEADERS = {
 
 
 async function initialization() {
+    if (CONFIG.CHROME_PATH == null) {
+        try {
+            CONFIG.CHROME_PATH = puppeteer.executablePath();
+        } catch (error) {
+            CONFIG.CHROME_PATH = "/usr/bin/chromium";
+        }
+    }
+    Logger.info(`CHROME_PATH: ${CONFIG.CHROME_PATH}`, 'Server');
+    if (CONFIG.API.IS_CUSTOM_SSO) {
+        if (CONFIG.API.IS_TEMP_GROK2) {
+            await tempCookieManager.ensureCookies();
+        }
+        return;
+    }
     const ssoArray = process.env.SSO.split(',');
-    const ssorwArray = process.env.SSO_RW.split(',');
-    ssoArray.forEach((sso, index) => {
-        tokenManager.addToken(`sso-rw=${ssorwArray[index]};sso=${sso}`);
+    ssoArray.forEach((sso) => {
+        tokenManager.addToken(`sso-rw=${sso};sso=${sso}`);
     });
     console.log(JSON.stringify(tokenManager.getActiveTokens(), null, 2));
-    await Utils.get_signature()
+    Logger.info(`令牌加载完成，共加载: ${tokenManager.getTokenCount()}个令牌`, 'Server');
+    if (CONFIG.API.IS_TEMP_GROK2) {
+        await tempCookieManager.ensureCookies();
+        CONFIG.API.TEMP_COOKIE = tempCookieManager.cookies[tempCookieManager.currentIndex];
+    }
     Logger.info("初始化完成", 'Server');
 }
 
@@ -81,27 +105,47 @@ class AuthTokenManager {
         this.activeTokens = [];
         this.expiredTokens = new Map();
         this.tokenModelFrequency = new Map();
-        this.modelRateLimit = {
-            "grok-3": { RequestFrequency: 20 },
-            "grok-3-deepsearch": { RequestFrequency: 5 },
-            "grok-3-reasoning": { RequestFrequency: 5 }
-        };
+        if (CONFIG.API.IS_TEMP_GROK2) {
+            this.modelRateLimit = {
+                "grok-3": { RequestFrequency: 20 },
+                "grok-3-deepsearch": { RequestFrequency: 10 },
+                "grok-3-reasoning": { RequestFrequency: 10 }
+            };
+            this.modelInitFrequency = {
+                "grok-3": 0,
+                "grok-3-deepsearch": 0,
+                "grok-3-reasoning": 0
+            };
+        } else {
+            this.modelRateLimit = {
+                "grok-2": { RequestFrequency: 20 },
+                "grok-3": { RequestFrequency: 20 },
+                "grok-3-deepsearch": { RequestFrequency: 5 },
+                "grok-3-reasoning": { RequestFrequency: 5 }
+            };
+            this.modelInitFrequency = {
+                "grok-2": 0,
+                "grok-3": 0,
+                "grok-3-deepsearch": 0,
+                "grok-3-reasoning": 0
+            };
+        }
+
     }
 
     addToken(token) {
         if (!this.activeTokens.includes(token)) {
             this.activeTokens.push(token);
-            this.tokenModelFrequency.set(token, {
-                "grok-3": 0,
-                "grok-3-deepsearch": 0,
-                "grok-3-reasoning": 0
-            });
+            this.tokenModelFrequency.set(token, this.modelInitFrequency);
         }
     }
+    setToken(token) {
+        this.activeTokens = [token];
+        this.tokenModelFrequency.set(token, this.modelInitFrequency);
+    }
 
     getTokenByIndex(index, model) {
-        if (!this.modelRateLimit[model]) return;
-        if(this.activeTokens.length === 0){
+        if (this.activeTokens.length === 0) {
             return null;
         }
         const token = this.activeTokens[index];
@@ -110,6 +154,10 @@ class AuthTokenManager {
     }
 
     recordModelRequest(token, model) {
+        if (model.startsWith('grok-') && (model.includes('search') || model.includes('imageGen'))) {
+            model = model.split('-')[0] + '-' + model.split('-')[1];
+        }
+
         if (!this.modelRateLimit[model]) return;
         const tokenFrequency = this.tokenModelFrequency.get(token);
         if (tokenFrequency && tokenFrequency[model] !== undefined) {
@@ -118,11 +166,17 @@ class AuthTokenManager {
         this.checkAndRemoveTokenIfLimitReached(token);
     }
     setModelLimit(index, model) {
+        if (model.startsWith('grok-') && (model.includes('search') || model.includes('imageGen'))) {
+            model = model.split('-')[0] + '-' + model.split('-')[1];
+        }
         if (!this.modelRateLimit[model]) return;
         const tokenFrequency = this.tokenModelFrequency.get(this.activeTokens[index]);
         tokenFrequency[model] = 9999;
     }
     isTokenModelLimitReached(index, model) {
+        if (model.startsWith('grok-') && (model.includes('search') || model.includes('imageGen'))) {
+            model = model.split('-')[0] + '-' + model.split('-')[1];
+        }
         if (!this.modelRateLimit[model]) return;
         const token = this.activeTokens[index];
         const tokenFrequency = this.tokenModelFrequency.get(token);
@@ -160,16 +214,12 @@ class AuthTokenManager {
     }
 
     startTokenRecoveryProcess() {
+        if (CONFIG.API.IS_CUSTOM_SSO) return;
         setInterval(() => {
             const now = Date.now();
             for (const [token, expiredTime] of this.expiredTokens.entries()) {
                 if (now - expiredTime >= 2 * 60 * 60 * 1000) {
-                    this.tokenModelUsage.set(token, {
-                        "grok-3": 0,
-                        "grok-3-imageGen": 0,
-                        "grok-3-deepsearch": 0,
-                        "grok-3-reasoning": 0
-                    });
+                    this.tokenModelFrequency.set(token, this.modelInitFrequency);
                     this.activeTokens.push(token);
                     this.expiredTokens.delete(token);
                     Logger.info(`令牌${token}已恢复，已添加到可用令牌列表`, 'TokenManager');
@@ -188,66 +238,10 @@ class AuthTokenManager {
 }
 
 class Utils {
-    static async extractGrokHeaders() {
-        Logger.info("开始提取头信息", 'Server');
-        try {
-            // 启动浏览器
-            const browser = await puppeteer.launch({
-                headless: true,
-                args: [
-                    '--no-sandbox',
-                    '--disable-setuid-sandbox',
-                    '--disable-dev-shm-usage',
-                    '--disable-gpu'
-                ],
-                executablePath: CONFIG.CHROME_PATH
-            });
-
-            const page = await browser.newPage();
-            await page.goto('https://grok.com/', { waitUntil: 'domcontentloaded' });
-            await page.evaluate(() => {
-                return new Promise(resolve => setTimeout(resolve, 5000))
-            })
-            // 获取所有 Cookies
-            const cookies = await page.cookies();
-            const targetHeaders = ['x-anonuserid', 'x-challenge', 'x-signature'];
-            const extractedHeaders = {};
-            // 遍历 Cookies
-            for (const cookie of cookies) {
-                // 检查是否为目标头信息
-                if (targetHeaders.includes(cookie.name.toLowerCase())) {
-                    extractedHeaders[cookie.name.toLowerCase()] = cookie.value;
-                }
-            }
-            // 关闭浏览器
-            await browser.close();
-            // 打印并返回提取的头信息
-            Logger.info('提取的头信息:', JSON.stringify(extractedHeaders, null, 2), 'Server');
-            return extractedHeaders;
-
-        } catch (error) {
-            Logger.error('获取头信息出错:', error, 'Server');
-            return null;
-        }
-    }
-    static async get_signature() {
-        if (CONFIG.API.TEMP_COOKIE) {
-            return CONFIG.API.TEMP_COOKIE;
-        }
-        Logger.info("刷新认证信息", 'Server');
-        let retryCount = 0;
-        while (!CONFIG.API.TEMP_COOKIE || retryCount < CONFIG.RETRY.MAX_ATTEMPTS) {
-            let headers = await Utils.extractGrokHeaders();
-            if (headers) {
-                Logger.info("获取认证信息成功", 'Server');
-                CONFIG.API.TEMP_COOKIE = { cookie: `x-anonuserid=${headers["x-anonuserid"]}; x-challenge=${headers["x-challenge"]}; x-signature=${headers["x-signature"]}` };
-                return;
-            }
-            retryCount++;
-            if (retryCount >= CONFIG.RETRY.MAX_ATTEMPTS) {
-                throw new Error(`获取认证信息失败!`);
-            }
-        }
+    static delay(time) {
+        return new Promise(function (resolve) {
+            setTimeout(resolve, time)
+        });
     }
     static async organizeSearchResults(searchResults) {
         // 确保传入的是有效的搜索结果对象
@@ -266,13 +260,129 @@ class Utils {
         });
         return formattedResults.join('\n\n');
     }
-    static createAuthHeaders(model) {
-        return {
-            'cookie': `${tokenManager.getTokenByIndex(CONFIG.SSO_INDEX, model)}`
-        };
+    static async createAuthHeaders(model) {
+        return await tokenManager.getTokenByIndex(CONFIG.SSO_INDEX, model);
     }
 }
+class GrokTempCookieManager {
+    constructor() {
+        this.cookies = [];
+        this.currentIndex = 0;
+        this.isRefreshing = false;
+        this.initialCookieCount = CONFIG.API.GROK2_CONCURRENCY_LEVEL;
+        this.extractCount = 0;
+    }
+
+    async ensureCookies() {
+        // 如果 cookies 数量不足，则重新获取
+        if (this.cookies.length < this.initialCookieCount) {
+            await this.refreshCookies();
+        }
+    }
+    async extractGrokHeaders(browser) {
+        Logger.info("开始提取头信息", 'Server');
+        try {
+            const page = await browser.newPage();
+            await page.goto('https://grok.com/', { waitUntil: 'domcontentloaded' });
+            let waitTime = 0;
+            const targetHeaders = ['x-anonuserid', 'x-challenge', 'x-signature'];
+
+            while (true) {
+                const cookies = await page.cookies();
+                const extractedHeaders = cookies
+                    .filter(cookie => targetHeaders.includes(cookie.name.toLowerCase()))
+                    .map(cookie => `${cookie.name}=${cookie.value}`);
+
+                if (targetHeaders.every(header =>
+                    extractedHeaders.some(cookie => cookie && cookie.startsWith(header + '='))
+                )) {
+                    await browser.close();
+                    Logger.info('提取的头信息:', JSON.stringify(extractedHeaders, null, 2), 'Server');
+                    this.cookies.push(extractedHeaders.join(';'));
+                    this.extractCount++;
+                    return true;
+                }
+
+                await Utils.delay(500);
+                waitTime += 500;
+                if (waitTime >= 10000) {
+                    await browser.close();
+                    return null;
+                }
+            }
+        } catch (error) {
+            Logger.error('获取头信息出错:', error, 'Server');
+            return null;
+        }
+    }
+    async initializeTempCookies(count = 1) {
+        Logger.info(`初始化 ${count} 个认证信息`, 'Server');
+        const browserOptions = {
+            headless: true,
+            args: [
+                '--no-sandbox',
+                '--disable-setuid-sandbox',
+                '--disable-dev-shm-usage',
+                '--disable-gpu'
+            ],
+            executablePath: CONFIG.CHROME_PATH
+        };
+
+        const browsers = await Promise.all(
+            Array.from({ length: count }, () => puppeteer.launch(browserOptions))
+        );
 
+        const cookiePromises = browsers.map(browser => this.extractGrokHeaders(browser));
+        return Promise.all(cookiePromises);
+    }
+    async refreshCookies() {
+        if (this.isRefreshing) return;
+        this.isRefreshing = true;
+        this.extractCount = 0;
+        try {
+            // 获取新的 cookies
+            let retryCount = 0;
+            let remainingCount = this.initialCookieCount - this.cookies.length;
+
+            while (retryCount < CONFIG.RETRY.MAX_ATTEMPTS) {
+                await this.initializeTempCookies(remainingCount);
+                if (this.extractCount != remainingCount) {
+                    if (this.extractCount == 0) {
+                        Logger.error(`无法获取足够的有效 TempCookies，可能网络存在问题，当前数量：${this.cookies.length}`);
+                    } else if (this.extractCount < remainingCount) {
+                        remainingCount -= this.extractCount;
+                        this.extractCount = 0;
+                        retryCount++;
+                        await Utils.delay(1000 * retryCount);
+                    } else {
+                        break;
+                    }
+                } else {
+                    break;
+                }
+            }
+            if (this.currentIndex >= this.cookies.length) {
+                this.currentIndex = 0;
+            }
+
+            if (this.cookies.length < this.initialCookieCount) {
+                if (this.cookies.length !== 0) {
+                    // 如果已经获取到一些 TempCookies，则只提示警告错误
+                    Logger.error(`无法获取足够的有效 TempCookies，可能网络存在问题，当前数量：${this.cookies.length}`);
+                } else {
+                    // 如果未获取到任何 TempCookies，则抛出错误
+                    throw new Error(`无法获取足够的有效 TempCookies，可能网络存在问题，当前数量：${this.cookies.length}`);
+                }
+            }
+        } catch (error) {
+            Logger.error('刷新 cookies 失败:', error);
+        } finally {
+            Logger.info(`已提取${this.cookies.length}个TempCookies`, 'Server');
+            Logger.info(`提取的TempCookies为${JSON.stringify(this.cookies, null, 2)}`, 'Server');
+            this.isRefreshing = false;
+        }
+    }
+}
 
 class GrokApiClient {
     constructor(modelId) {
@@ -328,7 +438,7 @@ class GrokApiClient {
                 method: 'POST',
                 headers: {
                     ...CONFIG.DEFAULT_HEADERS,
-                    ...CONFIG.API.SIGNATURE_COOKIE
+                    "cookie": CONFIG.API.SIGNATURE_COOKIE
                 },
                 body: JSON.stringify(uploadData)
             });
@@ -349,10 +459,10 @@ class GrokApiClient {
     }
 
     async prepareChatRequest(request) {
-        if ((request.model === 'grok-2-imageGen' || request.model === 'grok-3-imageGen') && !CONFIG.API.PICGO_KEY && request.stream) {
-            throw new Error(`该模型流式输出需要配置PICGO图床密钥!`);
+        if ((request.model === 'grok-2-imageGen' || request.model === 'grok-3-imageGen') && !CONFIG.API.PICGO_KEY && !CONFIG.API.TUMY_KEY && request.stream) {
+            throw new Error(`该模型流式输出需要配置PICGO或者TUMY图床密钥!`);
         }
-        
+
         // 处理画图模型的消息限制
         let todoMessages = request.messages;
         if (request.model === 'grok-2-imageGen' || request.model === 'grok-3-imageGen') {
@@ -360,22 +470,22 @@ class GrokApiClient {
             if (lastMessage.role !== 'user') {
                 throw new Error('画图模型的最后一条消息必须是用户消息!');
             }
-            todoMessages = [lastMessage]; 
+            todoMessages = [lastMessage];
         }
-        
+
         const fileAttachments = [];
         let messages = '';
         let lastRole = null;
         let lastContent = '';
-        const search = request.model === 'grok-2-search';
-    
+        const search = request.model === 'grok-2-search' || request.model === 'grok-3-search';
+
         // 移除<think>标签及其内容和base64图片
         const removeThinkTags = (text) => {
             text = text.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
             text = text.replace(/!\[image\]\(data:.*?base64,.*?\)/g, '[图片]');
             return text;
         };
-    
+
         const processImageUrl = async (content) => {
             if (content.type === 'image_url' && content.image_url.url.includes('data:image')) {
                 const imageResponse = await this.uploadBase64Image(
@@ -386,7 +496,7 @@ class GrokApiClient {
             }
             return null;
         };
-    
+
         const processContent = async (content) => {
             if (Array.isArray(content)) {
                 let textContent = '';
@@ -407,11 +517,11 @@ class GrokApiClient {
             }
             return removeThinkTags(this.processMessageContent(content));
         };
-    
+
         for (const current of todoMessages) {
             const role = current.role === 'assistant' ? 'assistant' : 'user';
             const isLastMessage = current === todoMessages[todoMessages.length - 1];
-            
+
             // 处理图片附件
             if (isLastMessage && current.content) {
                 if (Array.isArray(current.content)) {
@@ -426,10 +536,10 @@ class GrokApiClient {
                     if (processedImage) fileAttachments.push(processedImage);
                 }
             }
-    
+
             // 处理文本内容
             const textContent = await processContent(current.content);
-            
+
             if (textContent || (isLastMessage && fileAttachments.length > 0)) {
                 if (role === lastRole && textContent) {
                     lastContent += '\n' + textContent;
@@ -442,7 +552,7 @@ class GrokApiClient {
                 }
             }
         }
-    
+
         return {
             modelName: this.modelId,
             message: messages.trim(),
@@ -509,50 +619,51 @@ class MessageProcessor {
         };
     }
 }
-async function processModelResponse(linejosn, model) {
-    let result = { token: '', imageUrl: null }
+async function processModelResponse(response, model) {
+    let result = { token: null, imageUrl: null }
     if (CONFIG.IS_IMG_GEN) {
-        if (linejosn?.cachedImageGenerationResponse && !CONFIG.IS_IMG_GEN2) {
-            result.imageUrl = linejosn.cachedImageGenerationResponse.imageUrl;
+        if (response?.cachedImageGenerationResponse && !CONFIG.IS_IMG_GEN2) {
+            result.imageUrl = response.cachedImageGenerationResponse.imageUrl;
         }
         return result;
     }
-    var token = linejosn?.token
-    if (!token) return result;
+
     //非生图模型的处理
     switch (model) {
         case 'grok-2':
-            result.token = token;
+            result.token = response?.token;
             return result;
         case 'grok-2-search':
-            if (linejosn?.webSearchResults && CONFIG.ISSHOW_SEARCH_RESULTS) {
-                result.token = `\r\n<think>${await Utils.organizeSearchResults(linejosn.webSearchResults)}</think>\r\n`;
+        case 'grok-3-search':
+            if (response?.webSearchResults && CONFIG.ISSHOW_SEARCH_RESULTS) {
+                result.token = `\r\n<think>${await Utils.organizeSearchResults(response.webSearchResults)}</think>\r\n`;
             } else {
-                result.token = token;
+                result.token = response?.token;
             }
             return result;
         case 'grok-3':
-            result.token = token;
+            result.token = response?.token;
             return result;
         case 'grok-3-deepsearch':
-            if (linejosn.messageTag === "final") {
-                result.token = token;
+            if (response?.messageTag === "final") {
+                result.token = response?.token;
             }
             return result;
         case 'grok-3-reasoning':
-            if(linejosn?.isThinking && !CONFIG.SHOW_THINKING)return result;
+            if (response?.isThinking && !CONFIG.SHOW_THINKING) return result;
 
-            if (linejosn?.isThinking && !CONFIG.IS_THINKING) {
-                result.token = "<think>" + token;
+            if (response?.isThinking && !CONFIG.IS_THINKING) {
+                result.token = "<think>" + response?.token;
                 CONFIG.IS_THINKING = true;
-            } else if (CONFIG.IS_THINKING && !linejosn.isThinking) {
-                result.token = "</think>" + token;
+            } else if (!response.isThinking && CONFIG.IS_THINKING) {
+                result.token = "</think>" + response?.token;
                 CONFIG.IS_THINKING = false;
             } else {
-                result.token = token;
+                result.token = response?.token;
             }
             return result;
     }
+    return result;
 }
 
 async function handleResponse(response, model, res, isStream) {
@@ -561,8 +672,17 @@ async function handleResponse(response, model, res, isStream) {
         let buffer = '';
         let fullResponse = '';
         const dataPromises = [];
-        
-        return new Promise((resolve, reject) => { 
+        if (isStream) {
+            res.setHeader('Content-Type', 'text/event-stream');
+            res.setHeader('Cache-Control', 'no-cache');
+            res.setHeader('Connection', 'keep-alive');
+        }
+        CONFIG.IS_THINKING = false;
+        CONFIG.IS_IMG_GEN = false;
+        CONFIG.IS_IMG_GEN2 = false;
+        Logger.info("开始处理流式响应", 'Server');
+
+        return new Promise((resolve, reject) => {
             stream.on('data', async (chunk) => {
                 buffer += chunk.toString();
                 const lines = buffer.split('\n');
@@ -570,44 +690,46 @@ async function handleResponse(response, model, res, isStream) {
 
                 for (const line of lines) {
                     if (!line.trim()) continue;
-                    const trimmedLine = line.trim();
-                    if (trimmedLine.startsWith('data: ')) {
-                        const data = trimmedLine.substring(6);
-                        try {
-                            if (!data.trim()) continue;
-                            if(data === "[DONE]") continue;
-                            const linejosn = JSON.parse(data);
-                            if (linejosn?.error) {
-                                stream.destroy();
-                                reject(new Error("RateLimitError")); 
-                                return;
+                    try {
+                        const linejosn = JSON.parse(line.trim());
+                        if (linejosn?.error) {
+                            Logger.error(JSON.stringify(linejosn, null, 2), 'Server');
+                            if (linejosn.error?.name === "RateLimitError") {
+                                CONFIG.API.TEMP_COOKIE = null;
                             }
-                            if (linejosn?.doImgGen || linejosn?.imageAttachmentInfo) {
-                                CONFIG.IS_IMG_GEN = true;
-                            }
-                            const processPromise = (async () => {
-                                const result = await processModelResponse(linejosn, model);
-                                if (result.token) {
-                                    if (isStream) {
-                                        res.write(`data: ${JSON.stringify(MessageProcessor.createChatResponse(result.token, model, true))}\n\n`);
-                                    } else {
-                                        fullResponse += result.token;
-                                    }
+                            stream.destroy();
+                            reject(new Error("RateLimitError"));
+                            return;
+                        }
+                        let response = linejosn?.result?.response;
+                        if (!response) continue;
+                        if (response?.doImgGen || response?.imageAttachmentInfo) {
+                            CONFIG.IS_IMG_GEN = true;
+                        }
+                        const processPromise = (async () => {
+                            const result = await processModelResponse(response, model);
+
+                            if (result.token) {
+                                if (isStream) {
+                                    res.write(`data: ${JSON.stringify(MessageProcessor.createChatResponse(result.token, model, true))}\n\n`);
+                                } else {
+                                    fullResponse += result.token;
                                 }
-                                if (result.imageUrl) {
-                                    CONFIG.IS_IMG_GEN2 = true;
-                                    const dataImage = await handleImageResponse(result.imageUrl);
-                                    if (isStream) {
-                                        res.write(`data: ${JSON.stringify(MessageProcessor.createChatResponse(dataImage, model, true))}\n\n`);
-                                    } else {
-                                        res.json(MessageProcessor.createChatResponse(dataImage, model));
-                                    }
+                            }
+                            if (result.imageUrl) {
+                                CONFIG.IS_IMG_GEN2 = true;
+                                const dataImage = await handleImageResponse(result.imageUrl);
+                                if (isStream) {
+                                    res.write(`data: ${JSON.stringify(MessageProcessor.createChatResponse(dataImage, model, true))}\n\n`);
+                                } else {
+                                    res.json(MessageProcessor.createChatResponse(dataImage, model));
                                 }
-                            })();
-                            dataPromises.push(processPromise);
-                        } catch (error) {
-                            continue;
-                        }
+                            }
+                        })();
+                        dataPromises.push(processPromise);
+                    } catch (error) {
+                        Logger.error(error, 'Server');
+                        continue;
                     }
                 }
             });
@@ -621,25 +743,23 @@ async function handleResponse(response, model, res, isStream) {
                     } else {
                         if (!CONFIG.IS_IMG_GEN2) {
                             res.json(MessageProcessor.createChatResponse(fullResponse, model));
-                        }                        
+                        }
                     }
-                    CONFIG.IS_IMG_GEN = false;
-                    CONFIG.IS_IMG_GEN2 = false;
-                    resolve(); 
+                    resolve();
                 } catch (error) {
-                    reject(error); 
+                    Logger.error(error, 'Server');
+                    reject(error);
                 }
             });
 
             stream.on('error', (error) => {
-                reject(error); 
+                Logger.error(error, 'Server');
+                reject(error);
             });
         });
     } catch (error) {
         Logger.error(error, 'Server');
-        CONFIG.IS_IMG_GEN = false;
-        CONFIG.IS_IMG_GEN2 = false;
-        throw error;
+        throw new Error(error);
     }
 }
 
@@ -654,11 +774,11 @@ async function handleImageResponse(imageUrl) {
                 method: 'GET',
                 headers: {
                     ...DEFAULT_HEADERS,
-                    ...CONFIG.API.SIGNATURE_COOKIE
+                    "cookie": CONFIG.API.SIGNATURE_COOKIE
                 }
             });
 
-            if (imageBase64Response.ok) break; 
+            if (imageBase64Response.ok) break;
             retryCount++;
             if (retryCount === MAX_RETRIES) {
                 throw new Error(`上游服务请求失败! status: ${imageBase64Response.status}`);
@@ -666,6 +786,7 @@ async function handleImageResponse(imageUrl) {
             await new Promise(resolve => setTimeout(resolve, CONFIG.API.RETRY_TIME * retryCount));
 
         } catch (error) {
+            Logger.error(error, 'Server');
             retryCount++;
             if (retryCount === MAX_RETRIES) {
                 throw error;
@@ -678,38 +799,69 @@ async function handleImageResponse(imageUrl) {
     const arrayBuffer = await imageBase64Response.arrayBuffer();
     const imageBuffer = Buffer.from(arrayBuffer);
 
-    if(!CONFIG.API.PICGO_KEY){
+    if (!CONFIG.API.PICGO_KEY && !CONFIG.API.TUMY_KEY) {
         const base64Image = imageBuffer.toString('base64');
         const imageContentType = imageBase64Response.headers.get('content-type');
         return `![image](data:${imageContentType};base64,${base64Image})`
     }
 
+    Logger.info("开始上传图床", 'Server');
     const formData = new FormData();
-
-    formData.append('source', imageBuffer, {
-        filename: 'new.jpg',
-        contentType: 'image/jpeg'
-    });
-    const formDataHeaders = formData.getHeaders();
-    const responseURL = await fetch("https://www.picgo.net/api/1/upload", {
-        method: "POST",
-        headers: {
-            ...formDataHeaders,
-            "Content-Type": "multipart/form-data",
-            "X-API-Key": CONFIG.API.PICGO_KEY
-        },
-        body: formData
-    });
-    if (!responseURL.ok) {
-        return "生图失败，请查看图床密钥是否设置正确"
-    } else {
-        console.log("生图成功");
-        const result = await responseURL.json();
-        return `![image](${result.image.url})`
+    if (CONFIG.API.PICGO_KEY) {
+        formData.append('source', imageBuffer, {
+            filename: `image-${Date.now()}.jpg`,
+            contentType: 'image/jpeg'
+        });
+        const formDataHeaders = formData.getHeaders();
+        const responseURL = await fetch("https://www.picgo.net/api/1/upload", {
+            method: "POST",
+            headers: {
+                ...formDataHeaders,
+                "Content-Type": "multipart/form-data",
+                "X-API-Key": CONFIG.API.PICGO_KEY
+            },
+            body: formData
+        });
+        if (!responseURL.ok) {
+            return "生图失败，请查看PICGO图床密钥是否设置正确"
+        } else {
+            Logger.info("生图成功", 'Server');
+            const result = await responseURL.json();
+            return `![image](${result.image.url})`
+        }
+    } else if (CONFIG.API.TUMY_KEY) {
+        const formData = new FormData();
+        formData.append('file', imageBuffer, {
+            filename: `image-${Date.now()}.jpg`,
+            contentType: 'image/jpeg'
+        });
+        const formDataHeaders = formData.getHeaders();
+        const responseURL = await fetch("https://tu.my/api/v1/upload", {
+            method: "POST",
+            headers: {
+                ...formDataHeaders,
+                "Accept": "application/json",
+                'Authorization': `Bearer ${CONFIG.API.TUMY_KEY}`
+            },
+            body: formData
+        });
+        if (!responseURL.ok) {
+            return "生图失败，请查看TUMY图床密钥是否设置正确"
+        } else {
+            try {
+                const result = await responseURL.json();
+                Logger.info("生图成功", 'Server');
+                return `![image](${result.data.links.url})`
+            } catch (error) {
+                Logger.error(error, 'Server');
+                return "生图失败，请查看TUMY图床密钥是否设置正确"
+            }
+        }
     }
 }
 
 const tokenManager = new AuthTokenManager();
+const tempCookieManager = new GrokTempCookieManager();
 await initialization();
 
 // 中间件配置
@@ -739,53 +891,43 @@ app.get('/hf/v1/models', (req, res) => {
 app.post('/hf/v1/chat/completions', async (req, res) => {
     try {
         const authToken = req.headers.authorization?.replace('Bearer ', '');
-        if (authToken !== CONFIG.API.API_KEY) {
+        if (CONFIG.API.IS_CUSTOM_SSO) {
+            if (authToken) {
+                const result = `sso=${authToken};ssp_rw=${authToken}`;
+                tokenManager.setToken(result);
+            } else {
+                return res.status(401).json({ error: '自定义的SSO令牌缺失' });
+            }
+        } else if (authToken !== CONFIG.API.API_KEY) {
             return res.status(401).json({ error: 'Unauthorized' });
         }
-        let isTempCookie = req.body.model.includes("grok-2");
+        let isTempCookie = req.body.model.includes("grok-2") && CONFIG.API.IS_TEMP_GROK2;
         let retryCount = 0;
-        
+        const grokClient = new GrokApiClient(req.body.model);
+        const requestPayload = await grokClient.prepareChatRequest(req.body);
+        Logger.info(`请求体: ${JSON.stringify(requestPayload, null, 2)}`, 'Server');
+
         while (retryCount < CONFIG.RETRY.MAX_ATTEMPTS) {
             retryCount++;
-            const grokClient = new GrokApiClient(req.body.model);
-            const requestPayload = await grokClient.prepareChatRequest(req.body);       
-
-            if (!CONFIG.API.TEMP_COOKIE) {
-                await Utils.get_signature();
-            }
-
             if (isTempCookie) {
                 CONFIG.API.SIGNATURE_COOKIE = CONFIG.API.TEMP_COOKIE;
                 Logger.info(`已切换为临时令牌`, 'Server');
             } else {
-                CONFIG.API.SIGNATURE_COOKIE = Utils.createAuthHeaders(req.body.model);
+                CONFIG.API.SIGNATURE_COOKIE = await Utils.createAuthHeaders(req.body.model);
+            }
+            if (!CONFIG.API.SIGNATURE_COOKIE) {
+                throw new Error('该模型无可用令牌');
             }
             Logger.info(`当前令牌索引: ${CONFIG.SSO_INDEX}`, 'Server');
-            const newMessageReq = await fetch(`${CONFIG.API.BASE_URL}/api/rpc`, {
-                method: 'POST',
-                headers: {
-                    ...DEFAULT_HEADERS,
-                    ...CONFIG.API.SIGNATURE_COOKIE
-                },
-                body: JSON.stringify({
-                    rpc: "createConversation",
-                    req: {
-                        temporary: false
-                    }
-                })
-            });
-
-            const responseText = await newMessageReq.json();
-            const conversationId = responseText.conversationId;
-
-            const response = await fetch(`${CONFIG.API.BASE_URL}/api/conversations/${conversationId}/responses`, {
+            Logger.info(`当前令牌: ${JSON.stringify(CONFIG.API.SIGNATURE_COOKIE, null, 2)}`, 'Server');
+            const response = await fetch(`${CONFIG.API.BASE_URL}/rest/app-chat/conversations/new`, {
                 method: 'POST',
                 headers: {
                     "accept": "text/event-stream",
                     "baggage": "sentry-public_key=b311e0f2690c81f25e2c4cf6d4f7ce1c",
                     "content-type": "text/plain;charset=UTF-8",
                     "Connection": "keep-alive",
-                    ...CONFIG.API.SIGNATURE_COOKIE
+                    "cookie": CONFIG.API.SIGNATURE_COOKIE
                 },
                 body: JSON.stringify(requestPayload)
             });
@@ -796,11 +938,27 @@ app.post('/hf/v1/chat/completions', async (req, res) => {
                 Logger.info(`当前剩余可用令牌数: ${tokenManager.getTokenCount()}`, 'Server');
                 try {
                     await handleResponse(response, req.body.model, res, req.body.stream);
-                    return; 
+                    Logger.info(`请求结束`, 'Server');
+                    return;
                 } catch (error) {
-                    if(isTempCookie){
-                        await Utils.get_signature();
-                    }else{
+                    Logger.error(error, 'Server');
+                    if (isTempCookie) {
+                        // 移除当前失效的 cookie
+                        tempCookieManager.cookies.splice(tempCookieManager.currentIndex, 1);
+                        if (tempCookieManager.cookies.length != 0) {
+                            tempCookieManager.currentIndex = tempCookieManager.currentIndex % tempCookieManager.cookies.length;
+                            CONFIG.API.TEMP_COOKIE = tempCookieManager.cookies[tempCookieManager.currentIndex];
+                            tempCookieManager.ensureCookies()
+                        } else {
+                            try {
+                                await tempCookieManager.ensureCookies();
+                                tempCookieManager.currentIndex = tempCookieManager.currentIndex % tempCookieManager.cookies.length;
+                                CONFIG.API.TEMP_COOKIE = tempCookieManager.cookies[tempCookieManager.currentIndex];
+                            } catch (error) {
+                                throw error;
+                            }
+                        }
+                    } else {
                         tokenManager.setModelLimit(CONFIG.SSO_INDEX, req.body.model);
                         for (let i = 1; i <= tokenManager.getTokenCount(); i++) {
                             CONFIG.SSO_INDEX = (CONFIG.SSO_INDEX + 1) % tokenManager.getTokenCount();
@@ -815,7 +973,21 @@ app.post('/hf/v1/chat/completions', async (req, res) => {
             } else {
                 if (response.status === 429) {
                     if (isTempCookie) {
-                        await Utils.get_signature();
+                        // 移除当前失效的 cookie
+                        tempCookieManager.cookies.splice(tempCookieManager.currentIndex, 1);
+                        if (tempCookieManager.cookies.length != 0) {
+                            tempCookieManager.currentIndex = tempCookieManager.currentIndex % tempCookieManager.cookies.length;
+                            CONFIG.API.TEMP_COOKIE = tempCookieManager.cookies[tempCookieManager.currentIndex];
+                            tempCookieManager.ensureCookies()
+                        } else {
+                            try {
+                                await tempCookieManager.ensureCookies();
+                                tempCookieManager.currentIndex = tempCookieManager.currentIndex % tempCookieManager.cookies.length;
+                                CONFIG.API.TEMP_COOKIE = tempCookieManager.cookies[tempCookieManager.currentIndex];
+                            } catch (error) {
+                                throw error;
+                            }
+                        }
                     } else {
                         tokenManager.setModelLimit(CONFIG.SSO_INDEX, req.body.model);
                         for (let i = 1; i <= tokenManager.getTokenCount(); i++) {
@@ -830,7 +1002,21 @@ app.post('/hf/v1/chat/completions', async (req, res) => {
                 } else {
                     // 非429错误直接抛出
                     if (isTempCookie) {
-                        await Utils.get_signature();
+                        // 移除当前失效的 cookie
+                        tempCookieManager.cookies.splice(tempCookieManager.currentIndex, 1);
+                        if (tempCookieManager.cookies.length != 0) {
+                            tempCookieManager.currentIndex = tempCookieManager.currentIndex % tempCookieManager.cookies.length;
+                            CONFIG.API.TEMP_COOKIE = tempCookieManager.cookies[tempCookieManager.currentIndex];
+                            tempCookieManager.ensureCookies()
+                        } else {
+                            try {
+                                await tempCookieManager.ensureCookies();
+                                tempCookieManager.currentIndex = tempCookieManager.currentIndex % tempCookieManager.cookies.length;
+                                CONFIG.API.TEMP_COOKIE = tempCookieManager.cookies[tempCookieManager.currentIndex];
+                            } catch (error) {
+                                throw error;
+                            }
+                        }
                     } else {
                         Logger.error(`令牌异常错误状态!status: ${response.status}， 已移除当前令牌${CONFIG.SSO_INDEX.cookie}`, 'Server');
                         tokenManager.removeTokenByIndex(CONFIG.SSO_INDEX);
@@ -845,10 +1031,8 @@ app.post('/hf/v1/chat/completions', async (req, res) => {
         Logger.error(error, 'ChatAPI');
         res.status(500).json({
             error: {
-                message: error.message,
-                type: 'server_error',
-                param: null,
-                code: error.code || null
+                message: error.message || error,
+                type: 'server_error'
             }
         });
     }