Update index.js

index.js

@@ -12,16 +12,13 @@ dotenv.config();
  */
 class Config {
     constructor() {
-        // 主API Key池 (可用于新请求)
-        this.apiKeys = [];
-      
         this.initializeApiKeys();
         this.initializeAuth();
-
-        // 已使用的API Key池 (成功请求后放入，用于循环使用)
+        
+        // 已使用的API Key池
         this.usedApiKeys = [];
         
-        // 失效的API Key池 (永久失效，不再使用)
+        // 失效的API Key池
         this.invalidApiKeys = [];
         
         // Gemini安全设置
@@ -82,24 +79,24 @@ class Config {
     
     /**
      * 获取可用的API Key（负载均衡）
-     * 只负责从主池获取一个key，不负责移动到used池
      */
-    getApiKeyForRequest() {
+    getApiKey() {
         if (this.apiKeys.length === 0) {
             if (this.usedApiKeys.length > 0) {
-                // 如果主池为空，则从已使用池回收key
                 this.apiKeys.push(...this.usedApiKeys);
                 this.usedApiKeys = [];
-                console.log('🔄 回收已使用的API Keys到主池。');
             } else {
-                return null; // 没有可用的key
+                return null;
             }
         }
-        return this.apiKeys.shift(); // 从主池取出第一个key
+        
+        const apiKey = this.apiKeys.shift();
+        this.usedApiKeys.push(apiKey);
+        return apiKey;
     }
     
     /**
-     * 获取第一个可用的API Key（用于模型列表请求等非核心请求）
+     * 获取第一个可用的API Key（用于模型列表请求）
      */
     getFirstAvailableApiKey() {
         if (this.apiKeys.length > 0) {
@@ -115,36 +112,31 @@ class Config {
      * 将API Key标记为失效
      */
     markKeyAsInvalid(apiKey) {
-        // 从所有池中移除
-        this.apiKeys = this.apiKeys.filter(key => key !== apiKey);
-        this.usedApiKeys = this.usedApiKeys.filter(key => key !== apiKey);
+        const usedIndex = this.usedApiKeys.indexOf(apiKey);
+        if (usedIndex !== -1) {
+            this.usedApiKeys.splice(usedIndex, 1);
+        }
         
-        // 添加到失效池 (如果不在里面)
-        if (apiKey && !this.invalidApiKeys.includes(apiKey)) {
+        const mainIndex = this.apiKeys.indexOf(apiKey);
+        if (mainIndex !== -1) {
+            this.apiKeys.splice(mainIndex, 1);
+        }
+        
+        if (!this.invalidApiKeys.includes(apiKey)) {
             this.invalidApiKeys.push(apiKey);
         }
         
-        console.warn(`⚠️ API Key 已标记为失效: ${apiKey ? apiKey.substring(0, 10) : 'N/A'}...`);
-        console.warn(`当前可用API Keys: ${this.apiKeys.length}, 已使用: ${this.usedApiKeys.length}, 失效: ${this.invalidApiKeys.length}`);
+        console.warn(`⚠️ API Key 已标记为失效: ${apiKey.substring(0, 10)}...`);
     }
     
     /**
-     * 将API Key返回到已使用池 (表示成功使用过，可以循环)
+     * 将API Key移回已使用池
      */
-    returnApiKeyToUsed(apiKey) {
-        if (apiKey && !this.usedApiKeys.includes(apiKey) && !this.invalidApiKeys.includes(apiKey)) {
+    moveToUsed(apiKey) {
+        if (!this.usedApiKeys.includes(apiKey)) {
             this.usedApiKeys.push(apiKey);
         }
     }
-
-    /**
-     * 将API Key返回到主池 (例如，遇到暂时性错误如429，放回队列末尾)
-     */
-    returnApiKeyToMain(apiKey) {
-        if (apiKey && !this.apiKeys.includes(apiKey) && !this.invalidApiKeys.includes(apiKey)) {
-            this.apiKeys.push(apiKey);
-        }
-    }
     
     /**
      * 验证授权头
@@ -272,9 +264,7 @@ class MessageConverter {
             
             // 角色转换
             if (role === 'system') {
-                // Gemini doesn't have a direct 'system' role. It's usually integrated into the first 'user' turn.
-                // For simplicity, we convert 'system' to 'user'.
-                role = 'user'; 
+                role = 'user';
             }
             
             if (role === 'assistant') {
@@ -292,14 +282,10 @@ class MessageConverter {
                 parts = await this.convertContentArray(content);
             } else {
                 // 其他格式，转为文本
-                console.warn(`未知的内容格式: ${typeof content}，将转为文本处理`);
                 parts = [{ text: String(content) }];
             }
             
-            // 合并相同角色的连续消息以符合Gemini的单轮对话结构
-            // Gemini API expects alternating user/model turns (e.g., user, model, user, model).
-            // If OpenAI messages have consecutive 'user' or 'assistant' roles,
-            // we should merge them into a single Gemini turn.
+            // 合并相同角色的连续消息
             if (role === currentRole) {
                 currentParts.push(...parts);
             } else {
@@ -352,8 +338,8 @@ class MessageConverter {
                 }
             } catch (error) {
                 console.error('转换内容项错误:', error);
-                // 出错时返回错误信息文本，而不是抛出异常，避免整个请求失败
-                parts.push({ text: `[内容项处理失败: ${error.message}]` });
+                // 出错时跳过该项，避免整个请求失败
+                continue;
             }
         }
         
@@ -437,7 +423,6 @@ class ModelManager {
         
         const apiKey = this.config.getFirstAvailableApiKey();
         if (!apiKey) {
-            console.log("无key")
             return {
                 success: false,
                 error: '没有可用的API Key',
@@ -454,11 +439,6 @@ class ModelManager {
             });
             
             if (!response.ok) {
-                console.log("请求模型失败");
-                // 如果是 403 错误，标记 key 失效
-                if (response.status === 403) {
-                     this.config.markKeyAsInvalid(apiKey);
-                }
                 return {
                     success: false,
                     error: `获取模型列表失败: ${response.status}`,
@@ -491,28 +471,23 @@ class ModelManager {
         const allowedPrefixes = [
             'models/gemini-2.5-flash',
             'models/gemini-2.0-flash',
-            'models/gemini-1.5-flash',
-            'models/gemini-1.5-pro' // 允许 Gemini 1.5 Pro 模型
+            'models/gemini-1.5-flash'
         ];
         
         const excludedModels = [
-            'models/gemini-1.5-flash-8b' // 排除特定的较小模型
+            'models/gemini-1.5-flash-8b'
         ];
         
         const filteredModels = models.filter(model => {
             const modelName = model.name;
             
-            // 排除特定模型
             if (excludedModels.some(excluded => modelName.startsWith(excluded))) {
                 return false;
             }
-            
-            // 允许特定的完整模型名 (例如, "models/gemini-2.5-pro" 不以任何前缀开始)
-            if (modelName === "models/gemini-2.5-pro" || modelName === "models/gemini-1.5-pro") {
+            if(modelName == "models/gemini-2.5-pro"){
                 return true;
             }
             
-            // 允许以特定前缀开头的模型
             return allowedPrefixes.some(prefix => modelName.startsWith(prefix));
         });
         
@@ -622,23 +597,6 @@ class ResponseConverter {
                     return `data: ${JSON.stringify(openaiChunk)}\n\n`;
                 }
             }
-            // 处理安全设置阻断等情况
-            if (geminiData.promptFeedback?.blockReason || geminiData.candidates?.[0]?.finishReason === 'SAFETY') {
-                console.warn('Gemini stream blocked:', geminiData.promptFeedback?.blockReason || 'SAFETY');
-                const openaiChunk = {
-                    id: requestId,
-                    object: 'chat.completion.chunk',
-                    created: Math.floor(Date.now() / 1000),
-                    model: model,
-                    choices: [{
-                        index: 0,
-                        delta: { content: `[Content blocked due to: ${geminiData.promptFeedback?.blockReason || 'SAFETY'}]` },
-                        finish_reason: 'content_filter'
-                    }]
-                };
-                return `data: ${JSON.stringify(openaiChunk)}\n\n`;
-            }
-
             return '';
         } catch (error) {
             console.error('转换流响应块错误:', error);
@@ -673,30 +631,9 @@ class ResponseConverter {
                         role: 'assistant',
                         content: text
                     },
-                    finish_reason: candidate.finishReason === 'STOP' ? 'stop' : 'length' // Gemini 'STOP' is stop, others often length
-                });
-            } else if (candidate.finishReason === 'SAFETY') {
-                // 如果有内容但被安全机制阻断
-                openaiResponse.choices.push({
-                    index: 0,
-                    message: {
-                        role: 'assistant',
-                        content: `Content generation was blocked due to safety policy.`
-                    },
-                    finish_reason: 'content_filter'
+                    finish_reason: candidate.finishReason === 'STOP' ? 'stop' : 'length'
                 });
             }
-        } else if (geminiResponse.promptFeedback && geminiResponse.promptFeedback.blockReason) {
-             // Handle content moderation blocks (even before candidate generation)
-             console.warn('Gemini response blocked:', geminiResponse.promptFeedback.blockReason);
-             openaiResponse.choices.push({
-                 index: 0,
-                 message: {
-                     role: 'assistant',
-                     content: `Content generation was blocked due to: ${geminiResponse.promptFeedback.blockReason}.`
-                 },
-                 finish_reason: 'content_filter'
-             });
         }
         
         // 尝试从usage信息中获取token使用量
@@ -712,24 +649,15 @@ class ResponseConverter {
     }
     
     /**
-     * 将文本内容分块为假流式响应的生成器
+     * 将文本拆分为假流式块
      */
-    static * chunkTextForFakeStream(text, requestId, model, chunkSize = 50) {
-        if (!text) {
-            yield `data: ${JSON.stringify({
-                id: requestId,
-                object: 'chat.completion.chunk',
-                created: Math.floor(Date.now() / 1000),
-                model: model,
-                choices: [{ index: 0, delta: { content: '' }, finish_reason: 'stop' }]
-            })}\n\n`;
-            return;
-        }
+    static splitTextToFakeStream(text, requestId, model) {
+        const chunks = [];
+        const chunkSize = 3; // 每个块包含的字符数
         
-        let offset = 0;
-        while (offset < text.length) {
-            const chunk = text.substring(offset, Math.min(offset + chunkSize, text.length));
-            offset += chunkSize;
+        for (let i = 0; i < text.length; i += chunkSize) {
+            const chunk = text.slice(i, i + chunkSize);
+            const isLast = i + chunkSize >= text.length;
             
             const openaiChunk = {
                 id: requestId,
@@ -739,25 +667,14 @@ class ResponseConverter {
                 choices: [{
                     index: 0,
                     delta: { content: chunk },
-                    finish_reason: null // Not yet finished
+                    finish_reason: isLast ? 'stop' : null
                 }]
             };
-            yield `data: ${JSON.stringify(openaiChunk)}\n\n`;
+            
+            chunks.push(`data: ${JSON.stringify(openaiChunk)}\n\n`);
         }
         
-        // Final chunk with finish_reason
-        const finalChunk = {
-            id: requestId,
-            object: 'chat.completion.chunk',
-            created: Math.floor(Date.now() / 1000),
-            model: model,
-            choices: [{
-                index: 0,
-                delta: {}, // Delta for final chunk might be empty
-                finish_reason: 'stop' // Indicate end of stream
-            }]
-        };
-        yield `data: ${JSON.stringify(finalChunk)}\n\n`;
+        return chunks;
     }
 }
 
@@ -769,7 +686,7 @@ class GeminiRealtimeStreamParser {
         this.response = response;
         this.onChunk = onChunk;
         this.buffer = '';
-        this.bufferLv = 0; // Tracks JSON object nesting level
+        this.bufferLv = 0;
         this.inString = false;
         this.escapeNext = false;
         this.decoder = new TextDecoder();
@@ -777,16 +694,11 @@ class GeminiRealtimeStreamParser {
     
     async start() {
         try {
-            const reader = this.response.body.getReader();
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done) break;
-                
-                const text = this.decoder.decode(value, { stream: true });
+            for await (const chunk of this.response.body) {
+                const text = this.decoder.decode(chunk, { stream: true });
                 await this.processText(text);
             }
             
-            // Handle any remaining buffer after stream ends
             await this.handleRemainingBuffer();
         } catch (error) {
             console.error('流式解析错误:', error);
@@ -796,24 +708,26 @@ class GeminiRealtimeStreamParser {
     
     async processText(text) {
         for (const char of text) {
-            // Handle escaped characters
             if (this.escapeNext) {
-                this.buffer += char;
+                if (this.bufferLv > 1) {
+                    this.buffer += char;
+                }
                 this.escapeNext = false;
                 continue;
             }
             
-            // Toggle inString state
-            if (char === '"') {
-                this.inString = !this.inString;
-            } else if (char === '\\' && this.inString) {
-                // Handle escape character itself within a string
+            if (char === '\\' && this.inString) {
                 this.escapeNext = true;
-                this.buffer += char; // Add the backslash to buffer
+                if (this.bufferLv > 1) {
+                    this.buffer += char;
+                }
                 continue;
             }
             
-            // Track JSON nesting level outside of strings
+            if (char === '"') {
+                this.inString = !this.inString;
+            }
+            
             if (!this.inString) {
                 if (char === '{' || char === '[') {
                     this.bufferLv++;
@@ -822,27 +736,33 @@ class GeminiRealtimeStreamParser {
                 }
             }
             
-            this.buffer += char; // Always add char to buffer
-            
-            // If we are at the top level of a complete JSON object (bufferLv === 0 for a root object)
-            // For Gemini's stream format, each object typically ends with } and is a standalone chunk
-            if (!this.inString && this.bufferLv === 0 && char === '}' && this.buffer.trim() !== '') {
+            if (this.bufferLv > 1) {
+                if (this.inString && char === '\n') {
+                    this.buffer += '\\n';
+                } else {
+                    this.buffer += char;
+                }
+            } else if (this.bufferLv === 1 && this.buffer) {
+                this.buffer += '}';
+                
                 try {
                     const bufferJson = JSON.parse(this.buffer);
                     await this.onChunk(bufferJson);
                 } catch (parseError) {
                     console.error('解析Gemini流数据错误:', parseError);
-                    // It's possible to get partial JSON or errors, log and clear buffer
                 }
-                this.buffer = ''; // Reset buffer after processing a complete object
+                
+                this.buffer = '';
             }
         }
     }
     
     async handleRemainingBuffer() {
-        if (this.buffer.trim() !== '') {
+        if (this.buffer.trim() && this.bufferLv >= 1) {
             try {
-                // Attempt to parse any remaining content as a full JSON object.
+                if (!this.buffer.endsWith('}')) {
+                    this.buffer += '}';
+                }
                 const bufferJson = JSON.parse(this.buffer);
                 await this.onChunk(bufferJson);
             } catch (parseError) {
@@ -896,7 +816,7 @@ class ApiProxyService {
     }
     
     /**
-     * 处理聊天API请求（支持图片）- 真实流式
+     * 处理聊天API请求（支持图片）
      */
     async handleChatRequest(req, res) {
         try {
@@ -920,7 +840,7 @@ class ApiProxyService {
             const requestBody = this.requestBuilder.buildRequestBody(geminiMessages, params);
             
             if (params.stream) {
-                const result = await this.executeRealStreamRequest(requestBody, params, requestId, res);
+                const result = await this.handleStreamRequest(requestBody, params, requestId, res);
                 if (!result.success) {
                     res.status(result.status || 500).json({ error: result.error });
                 }
@@ -945,9 +865,7 @@ class ApiProxyService {
     }
     
     /**
-     * 新增处理假流式聊天API请求
-     * 如果客户端请求流式，则内部调用非流式 Gemini API，然后转为假流发送给客户端。
-     * 如果客户端请求非流式，则直接代理非流式请求。
+     * 处理假流式聊天API请求
      */
     async handleFakeStreamChatRequest(req, res) {
         try {
@@ -955,6 +873,7 @@ class ApiProxyService {
             
             const params = MessageConverter.extractParams(req.body);
             
+            // 异步转换消息（支持图片处理）
             const geminiMessages = await MessageConverter.convertMessages(params.messages);
             
             if (!geminiMessages || geminiMessages.length === 0) {
@@ -966,17 +885,17 @@ class ApiProxyService {
                     }
                 });
             }
-            console.log("开始请求")
+            
             const requestBody = this.requestBuilder.buildRequestBody(geminiMessages, params);
             
             if (params.stream) {
-                // 客户端请求流式，但我们内部执行非流式 Gemini 请求，然后假流返回
-                const result = await this.executeFakeStreamResponse(requestBody, params, requestId, res);
+                // 假流式处理：使用非流式请求，然后模拟流式响应
+                const result = await this.handleFakeStreamRequest(requestBody, params, requestId, res);
                 if (!result.success) {
                     res.status(result.status || 500).json({ error: result.error });
                 }
             } else {
-                // 客户端请求非流式，直接执行非流式请求
+                // 非流式请求和原来一样
                 const result = await this.executeNormalRequest(requestBody, params, requestId);
                 if (result.success) {
                     res.json(result.data);
@@ -997,12 +916,80 @@ class ApiProxyService {
     }
     
     /**
-     * 执行真实的流式请求
+     * 处理假流式请求
+     */
+    async handleFakeStreamRequest(requestBody, params, requestId, res) {
+        try {
+            // 设置流式响应头
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+                'Access-Control-Allow-Origin': '*'
+            });
+            
+            // 开始发送ping消息保持连接活跃
+            const pingInterval = setInterval(() => {
+                try {
+                    res.write(': ping\n\n');
+                } catch (error) {
+                    clearInterval(pingInterval);
+                }
+            }, 1000); // 每秒发送一次ping
+            
+            // 执行非流式请求
+            const result = await this.executeNormalRequest(requestBody, params, requestId);
+            
+            // 停止ping
+            clearInterval(pingInterval);
+            
+            if (!result.success) {
+                res.write(`data: ${JSON.stringify({ error: result.error })}\n\n`);
+                res.write('data: [DONE]\n\n');
+                res.end();
+                return { success: false };
+            }
+            
+            // 获取响应文本
+            const responseText = result.data.choices[0]?.message?.content || '';
+            
+            if (responseText) {
+                // 将文本拆分为假流式块
+                const chunks = ResponseConverter.splitTextToFakeStream(responseText, requestId, params.model);
+                
+                // 逐步发送块，模拟流式响应
+                for (const chunk of chunks) {
+                    res.write(chunk);
+                    // 添加小延迟以模拟真实的流式响应
+                    await new Promise(resolve => setTimeout(resolve, 50));
+                }
+            }
+            
+            res.write('data: [DONE]\n\n');
+            res.end();
+            
+            return { success: true };
+            
+        } catch (error) {
+            console.error('处理假流式请求错误:', error);
+            try {
+                res.write(`data: ${JSON.stringify({ error: '内部服务器错误: ' + error.message })}\n\n`);
+                res.write('data: [DONE]\n\n');
+                res.end();
+            } catch (writeError) {
+                console.error('写入错误响应失败:', writeError);
+            }
+            return { success: false, error: error.message };
+        }
+    }
+    
+    /**
+     * 处理流式请求
      */
-    async executeRealStreamRequest(requestBody, params, requestId, res, retryCount = 0) {
+    async handleStreamRequest(requestBody, params, requestId, res, retryCount = 0) {
         const maxRetries = 3;
         
-        let apiKey = this.config.getApiKeyForRequest();
+        const apiKey = this.config.getApiKey();
         if (!apiKey) {
             return { success: false, error: '目前暂无可用的API Key', status: 503 };
         }
@@ -1019,40 +1006,30 @@ class ApiProxyService {
             if (response.status === 403) {
                 this.config.markKeyAsInvalid(apiKey);
                 if (retryCount < maxRetries) {
-                    console.log(`真实流式请求重试 ${retryCount + 1}/${maxRetries} (403错误)。`);
-                    return await this.executeRealStreamRequest(requestBody, params, requestId, res, retryCount + 1);
+                    return await this.handleStreamRequest(requestBody, params, requestId, res, retryCount + 1);
                 }
-                return { success: false, error: 'API Key 无效或已失效', status: 403 };
+                return { success: false, error: 'API Key 无效', status: 403 };
             }
             
             if (response.status === 429) {
-                this.config.returnApiKeyToMain(apiKey); // 放回主池末尾，等待冷却
+                this.config.moveToUsed(apiKey);
                 if (retryCount < maxRetries) {
-                    console.log(`真实流式请求重试 ${retryCount + 1}/${maxRetries} (429错误)。`);
-                    return await this.executeRealStreamRequest(requestBody, params, requestId, res, retryCount + 1);
+                    return await this.handleStreamRequest(requestBody, params, requestId, res, retryCount + 1);
                 }
                 return { success: false, error: '请求频率过高，请稍后重试', status: 429 };
             }
             
-            if (response.status >= 500 && response.status < 600) { // 5xx errors
-                this.config.returnApiKeyToMain(apiKey); // 服务器错误，放回主池
-                if (retryCount < maxRetries) {
-                    console.log(`真实流式请求重试 ${retryCount + 1}/${maxRetries} (${response.status}错误)。`);
-                    return await this.executeRealStreamRequest(requestBody, params, requestId, res, retryCount + 1);
-                }
-                return { success: false, error: '目前服务器繁忙，请稍后重试', status: response.status };
+            if (response.status === 500) {
+                this.config.moveToUsed(apiKey);
+                return { success: false, error: '目前服务器繁忙，请稍后重试', status: 500 };
             }
             
             if (!response.ok) {
                 const errorText = await response.text();
                 console.error(`API请求失败: ${response.status}, 错误信息: ${errorText}`);
-                this.config.returnApiKeyToMain(apiKey); // 其他非 2xx 错误，也放回主池
-                return { success: false, error: `API请求失败: ${response.status} - ${errorText.substring(0, 100)}`, status: response.status };
+                return { success: false, error: `API请求失败: ${response.status}`, status: response.status };
             }
             
-            // 如果请求成功，将 key 放入已使用池
-            this.config.returnApiKeyToUsed(apiKey);
-            
             res.writeHead(200, {
                 'Content-Type': 'text/event-stream',
                 'Cache-Control': 'no-cache',
@@ -1075,11 +1052,10 @@ class ApiProxyService {
             
         } catch (error) {
             console.error('执行流式请求错误:', error);
-            this.config.returnApiKeyToMain(apiKey); // 网络错误，放回主池
+            this.config.moveToUsed(apiKey);
             
             if (retryCount < maxRetries) {
-                console.log(`真实流式请求重试 ${retryCount + 1}/${maxRetries} (网络错误)。`);
-                return await this.executeRealStreamRequest(requestBody, params, requestId, res, retryCount + 1);
+                return await this.handleStreamRequest(requestBody, params, requestId, res, retryCount + 1);
             }
             
             return { success: false, error: '网络请求失败: ' + error.message, status: 500 };
@@ -1087,12 +1063,12 @@ class ApiProxyService {
     }
     
     /**
-     * 执行非流式请求
+     * 处理非流式请求
      */
     async executeNormalRequest(requestBody, params, requestId, retryCount = 0) {
         const maxRetries = 3;
         
-        let apiKey = this.config.getApiKeyForRequest();
+        const apiKey = this.config.getApiKey();
         if (!apiKey) {
             return { success: false, error: '目前暂无可用的API Key', status: 503 };
         }
@@ -1109,48 +1085,39 @@ class ApiProxyService {
             if (response.status === 403) {
                 this.config.markKeyAsInvalid(apiKey);
                 if (retryCount < maxRetries) {
-                    console.log(`非流式请求重试 ${retryCount + 1}/${maxRetries} (403错误)。`);
                     return await this.executeNormalRequest(requestBody, params, requestId, retryCount + 1);
                 }
-                return { success: false, error: 'API Key 无效或已失效', status: 403 };
+                return { success: false, error: 'API Key 无效', status: 403 };
             }
             
             if (response.status === 429) {
-                this.config.returnApiKeyToMain(apiKey);
+                this.config.moveToUsed(apiKey);
                 if (retryCount < maxRetries) {
-                    console.log(`非流式请求重试 ${retryCount + 1}/${maxRetries} (429错误)。`);
                     return await this.executeNormalRequest(requestBody, params, requestId, retryCount + 1);
                 }
                 return { success: false, error: '请求频率过高，请稍后重试', status: 429 };
             }
             
-            if (response.status >= 500 && response.status < 600) { // 5xx errors
-                this.config.returnApiKeyToMain(apiKey);
-                if (retryCount < maxRetries) {
-                    console.log(`非流式请求重试 ${retryCount + 1}/${maxRetries} (${response.status}错误)。`);
-                    return await this.executeNormalRequest(requestBody, params, requestId, retryCount + 1);
-                }
-                return { success: false, error: '目前服务器繁忙，请稍后重试', status: response.status };
+            if (response.status === 500) {
+                this.config.moveToUsed(apiKey);
+                return { success: false, error: '目前服务器繁忙，请稍后重试', status: 500 };
             }
             
             if (!response.ok) {
                 const errorText = await response.text();
                 console.error(`API请求失败: ${response.status}, 错误信息: ${errorText}`);
-                this.config.returnApiKeyToMain(apiKey);
-                return { success: false, error: `API请求失败: ${response.status} - ${errorText.substring(0, 100)}`, status: response.status };
+                return { success: false, error: `API请求失败: ${response.status}`, status: response.status };
             }
             
-            this.config.returnApiKeyToUsed(apiKey);
             const geminiResponse = await response.json();
             const openaiResponse = ResponseConverter.convertNormalResponse(geminiResponse, requestId, params.model);
             return { success: true, data: openaiResponse };
             
         } catch (error) {
             console.error('执行非流式请求错误:', error);
-            this.config.returnApiKeyToMain(apiKey);
+            this.config.moveToUsed(apiKey);
             
             if (retryCount < maxRetries) {
-                console.log(`非流式请求重试 ${retryCount + 1}/${maxRetries} (网络错误)。`);
                 return await this.executeNormalRequest(requestBody, params, requestId, retryCount + 1);
             }
             
@@ -1158,82 +1125,6 @@ class ApiProxyService {
         }
     }
     
-    /**
-     * 执行假流式响应 (内部调用非流式 Gemini API, 然后转换为流式响应)
-     */
-    async executeFakeStreamResponse(requestBody, params, requestId, res) {
-        let pingInterval;
-        const pingDelayMs = 1000; // 每1秒发送一次ping消息
-        
-        try {
-            res.writeHead(200, {
-                'Content-Type': 'text/event-stream',
-                'Cache-Control': 'no-cache',
-                'Connection': 'keep-alive',
-                'Access-Control-Allow-Origin': '*'
-            });
-            
-            // 开始发送ping消息
-            pingInterval = setInterval(() => {
-                const pingChunk = {
-                    id: requestId,
-                    object: 'chat.completion.chunk',
-                    created: Math.floor(Date.now() / 1000),
-                    model: params.model,
-                    choices: [{
-                        index: 0,
-                        delta: {}, // 空 delta 用于 ping
-                        finish_reason: null
-                    }]
-                };
-                // console.log('发送 ping 块...');
-                res.write(`data: ${JSON.stringify(pingChunk)}\n\n`);
-            }, pingDelayMs);
-            
-            // 执行实际的非流式请求到 Gemini
-            const result = await this.executeNormalRequest(requestBody, params, requestId);
-            
-            // 请求完成后立即清除 ping 间隔
-            clearInterval(pingInterval);
-            pingInterval = null; 
-            
-            if (result.success) {
-                const fullContent = result.data.choices[0]?.message?.content || '';
-                
-                // 将完整内容分块并以假流形式发送
-                for (const chunk of ResponseConverter.chunkTextForFakeStream(fullContent, requestId, params.model)) {
-                    res.write(chunk);
-                    // 可以添加一个小的延迟来模拟更真实的“流式”体验
-                    await new Promise(resolve => setTimeout(resolve, 50)); 
-                }
-                res.write('data: [DONE]\n\n');
-                res.end();
-                return { success: true };
-            } else {
-                // 如果非流式请求失败，发送错误块并结束流
-                res.write(`data: ${JSON.stringify({ error: result.error })}\n\n`);
-                res.write('data: [DONE]\n\n');
-                res.end();
-                return { success: false, error: result.error, status: result.status };
-            }
-            
-        } catch (error) {
-            console.error('执行假流式请求错误:', error);
-            if (pingInterval) {
-                clearInterval(pingInterval);
-            }
-            // 如果在响应发送前或发送过程中出现错误
-            res.status(500).json({
-                error: {
-                    message: '内部服务器错误: ' + error.message,
-                    type: 'internal_server_error',
-                    code: 'server_error'
-                }
-            });
-            return { success: false, error: '内部服务器错误: ' + error.message, status: 500 };
-        }
-    }
-    
     /**
      * 处理模型列表请求
      */
@@ -1244,7 +1135,6 @@ class ApiProxyService {
             if (result.success) {
                 res.json(result.data);
             } else {
-                console.log("失败");
                 res.status(result.status || 500).json({ error: result.error });
             }
         } catch (error) {
@@ -1292,35 +1182,36 @@ class Server {
     }
     
     setupRoutes() {
-        // 聊天接口（支持图片，真实流式）
+        // 原始聊天接口（支持图片）
         this.app.post('/v1/chat/completions', (req, res) => {
             this.apiProxy.handleChatRequest(req, res);
         });
         
-        // 新增聊天接口（支持图片，假流式）
+        // 假流式聊天接口
         this.app.post('/fakestream/v1/chat/completions', (req, res) => {
             this.apiProxy.handleFakeStreamChatRequest(req, res);
         });
         
-        // 模型列表接口
+        // 原始模型列表接口
         this.app.get('/v1/models', (req, res) => {
             this.apiProxy.handleModelsRequest(req, res);
         });
-        // 模型列表接口
+        
+        // 假流式模型列表接口（逻辑相同）
         this.app.get('/fakestream/v1/models', (req, res) => {
             this.apiProxy.handleModelsRequest(req, res);
-        });        
+        });
+        
         // 健康检查接口
         this.app.get('/health', (req, res) => {
             res.json({ 
                 status: 'healthy',
                 timestamp: new Date().toISOString(),
-                availableKeys: this.apiProxy.config.apiKeys.length, // 可用于新请求的key
-                usedKeys: this.apiProxy.config.usedApiKeys.length,   // 成功使用过的key (待下次循环)
-                invalidKeys: this.apiProxy.config.invalidApiKeys.length, // 已失效的key
-                totalKeysConfigured: this.apiProxy.config.apiKeys.length + this.apiProxy.config.usedApiKeys.length + this.apiProxy.config.invalidApiKeys.length,
-                version: '2.1.0', // 更新版本号以反映新功能
-                features: ['text', 'vision', 'stream_real', 'stream_fake', 'load_balancing']
+                availableKeys: this.apiProxy.config.apiKeys.length,
+                usedKeys: this.apiProxy.config.usedApiKeys.length,
+                invalidKeys: this.apiProxy.config.invalidApiKeys.length,
+                version: '2.0.0',
+                features: ['text', 'vision', 'stream', 'fake_stream', 'load_balancing']
             });
         });
         
@@ -1351,9 +1242,10 @@ class Server {
     start(port = 3000) {
         this.app.listen(port, () => {
             console.log(`🚀 OpenAI to Gemini Proxy Server (Enhanced) 启动在端口 ${port}`);
-            console.log(`📍 真实流式聊天API: http://localhost:${port}/v1/chat/completions`);
-            console.log(`📍 假流式聊天API (新功能): http://localhost:${port}/v1/chat/completions/fakestream`);
+            console.log(`📍 聊天API: http://localhost:${port}/v1/chat/completions`);
+            console.log(`📍 假流式聊天API: http://localhost:${port}/fakestream/v1/chat/completions`);
             console.log(`📋 模型列表: http://localhost:${port}/v1/models`);
+            console.log(`📋 假流式模型列表: http://localhost:${port}/fakestream/v1/models`);
             console.log(`🔍 健康检查: http://localhost:${port}/health`);
         });
     }
@@ -1362,4 +1254,4 @@ class Server {
 // 启动服务器
 const server = new Server();
 const port = process.env.PORT || 3000;
-server.start(port);
+server.start(port);