Update index.js

index.js

@@ -1378,10 +1378,7 @@ class ApiProxyService {
 
             if (params.stream) {
                 // 假流式处理：使用非流式请求，然后模拟流式响应
-                const result = await this.handleFakeStreamRequest(requestBody, params, requestId, res, req.authKey, logData, startTime);
-                if (!result.success) {
-                    res.status(result.status || 500).json({ error: result.error });
-                }
+                await this.handleFakeStreamRequest(requestBody, params, requestId, res, req.authKey, logData, startTime);
             } else {
                 // 非流式请求和原来一样
                 const result = await this.executeNormalRequest(requestBody, params, requestId);
@@ -1408,44 +1405,30 @@ class ApiProxyService {
             logData.duration = Date.now() - startTime;
             this.logRequest(req.authKey, logData);
 
-            res.status(500).json({
-                error: {
-                    message: '内部服务器错误: ' + error.message,
-                    type: 'internal_server_error',
-                    code: 'server_error'
-                }
-            });
+            // 修复：确保在错误情况下正确响应
+            if (!res.headersSent) {
+                res.status(500).json({
+                    error: {
+                        message: '内部服务器错误: ' + error.message,
+                        type: 'internal_server_error',
+                        code: 'server_error'
+                    }
+                });
+            }
         }
     }
 
     /**
-     * 处理假流式请求
+     * 处理假流式请求（修复版）
      */
     async handleFakeStreamRequest(requestBody, params, requestId, res, authKey, logData, startTime) {
-        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
+        let responseStarted = false;
+        let pingInterval = null;
 
+        try {
             // 执行非流式请求
             const result = await this.executeNormalRequest(requestBody, params, requestId);
 
-            // 停止ping
-            clearInterval(pingInterval);
-
             logData.responseTime = new Date().toISOString();
             logData.duration = Date.now() - startTime;
 
@@ -1454,10 +1437,34 @@ class ApiProxyService {
                 logData.error = result.error;
                 this.logRequest(authKey, logData);
 
-                res.write(`data: ${JSON.stringify({ error: result.error })}\n\n`);
-                res.write('data: [DONE]\n\n');
-                res.end();
-                return { success: false };
+                // 发送错误响应为流式格式
+                if (!res.headersSent) {
+                    res.writeHead(200, {
+                        'Content-Type': 'text/event-stream',
+                        'Cache-Control': 'no-cache',
+                        'Connection': 'keep-alive',
+                        'Access-Control-Allow-Origin': '*'
+                    });
+                    responseStarted = true;
+                }
+
+                if (responseStarted) {
+                    const errorChunk = {
+                        id: requestId,
+                        object: 'chat.completion.chunk',
+                        created: Math.floor(Date.now() / 1000),
+                        model: params.model,
+                        choices: [{
+                            index: 0,
+                            delta: { content: `错误: ${result.error}` },
+                            finish_reason: 'stop'
+                        }]
+                    };
+                    res.write(`data: ${JSON.stringify(errorChunk)}\n\n`);
+                    res.write('data: [DONE]\n\n');
+                    res.end();
+                }
+                return;
             }
 
             // 获取响应文本
@@ -1465,22 +1472,50 @@ class ApiProxyService {
             logData.responseContent = responseText;
             this.logRequest(authKey, logData);
 
-            if (responseText) {
+            // 设置流式响应头
+            if (!res.headersSent) {
+                res.writeHead(200, {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'keep-alive',
+                    'Access-Control-Allow-Origin': '*'
+                });
+                responseStarted = true;
+                
+                // 开始发送ping消息保持连接活跃
+                pingInterval = setInterval(() => {
+                    try {
+                        if (!res.destroyed) {
+                            res.write(': ping\n\n');
+                        }
+                    } catch (error) {
+                        clearInterval(pingInterval);
+                    }
+                }, 1000);
+            }
+
+            if (responseText && responseStarted) {
                 // 将文本拆分为假流式块
                 const chunks = ResponseConverter.splitTextToFakeStream(responseText, requestId, params.model);
 
                 // 逐步发送块，模拟流式响应
                 for (const chunk of chunks) {
+                    if (res.destroyed) break;
                     res.write(chunk);
                     // 添加小延迟以模拟真实的流式响应
-                    await new Promise(resolve => setTimeout(resolve, 10));
+                    await new Promise(resolve => setTimeout(resolve, 50));
                 }
             }
 
-            res.write('data: [DONE]\n\n');
-            res.end();
-
-            return { success: true };
+            // 停止ping并结束响应
+            if (pingInterval) {
+                clearInterval(pingInterval);
+            }
+            
+            if (responseStarted && !res.destroyed) {
+                res.write('data: [DONE]\n\n');
+                res.end();
+            }
 
         } catch (error) {
             console.error('处理假流式请求错误:', error);
@@ -1491,14 +1526,48 @@ class ApiProxyService {
             logData.duration = Date.now() - startTime;
             this.logRequest(authKey, logData);
 
-            try {
-                res.write(`data: ${JSON.stringify({ error: '内部服务器错误: ' + error.message })}\n\n`);
-                res.write('data: [DONE]\n\n');
-                res.end();
-            } catch (writeError) {
-                console.error('写入错误响应失败:', writeError);
+            // 停止ping
+            if (pingInterval) {
+                clearInterval(pingInterval);
+            }
+
+            // 如果还没有开始响应，设置流式响应头
+            if (!res.headersSent && !responseStarted) {
+                try {
+                    res.writeHead(200, {
+                        'Content-Type': 'text/event-stream',
+                        'Cache-Control': 'no-cache',
+                        'Connection': 'keep-alive',
+                        'Access-Control-Allow-Origin': '*'
+                    });
+                    responseStarted = true;
+                } catch (headerError) {
+                    console.error('设置响应头失败:', headerError);
+                    return;
+                }
+            }
+
+            // 发送错误信息
+            if (responseStarted && !res.destroyed) {
+                try {
+                    const errorChunk = {
+                        id: requestId,
+                        object: 'chat.completion.chunk',
+                        created: Math.floor(Date.now() / 1000),
+                        model: params.model,
+                        choices: [{
+                            index: 0,
+                            delta: { content: `错误: ${error.message}` },
+                            finish_reason: 'stop'
+                        }]
+                    };
+                    res.write(`data: ${JSON.stringify(errorChunk)}\n\n`);
+                    res.write('data: [DONE]\n\n');
+                    res.end();
+                } catch (writeError) {
+                    console.error('写入错误响应失败:', writeError);
+                }
             }
-            return { success: false, error: error.message };
         }
     }
 
@@ -2027,7 +2096,7 @@ class Server {
                 invalidKeys: this.apiProxy.config.invalidApiKeys.length,
                 authKeys: this.apiProxy.authKeyManager.getAllKeys().length,
                 fileLoggingEnabled: this.apiProxy.logManager.getFileLoggingStatus(),
-                version: '2.3.0',
+                version: '2.3.1',
                 features: ['text', 'vision', 'stream', 'fake_stream', 'load_balancing', 'auto_retry', 'logging', 'multi_auth', 'file_export']
             });
         });