fix: 修复流式响应的 Parse Error 和缓冲问题

主要修改：
1. 从 compression 中间件中排除 SSE 流式响应，避免压缩导致的缓冲
2. 移除导致 Parse Error 的 res.flushHeaders() 调用
3. 改进流式响应的错误处理，发送 SSE 错误事件而不是破坏流
4. 在写入数据前检查流状态，避免写入已销毁的流
5. 优化响应结束时的处理逻辑，确保缓冲区数据正确处理

这些修改确保了流式请求能够正常显示打字机效果，同时保留了 usage token 收集功能。

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

src/routes/api.js

@@ -47,11 +47,8 @@ async function handleMessagesRequest(req, res) {
       res.setHeader('Access-Control-Allow-Origin', '*');
       res.setHeader('X-Accel-Buffering', 'no'); // 禁用 Nginx 缓冲
       
-      // 立即发送响应头，防止缓冲
-      res.flushHeaders();
-      
       // 禁用 Nagle 算法，确保数据立即发送
-      if (res.socket && res.socket.setNoDelay) {
+      if (res.socket && typeof res.socket.setNoDelay === 'function') {
         res.socket.setNoDelay(true);
       }
       

src/services/claudeRelayService.js

@@ -680,12 +680,35 @@ class ClaudeRelayService {
       }
 
       const req = https.request(options, (res) => {
-        // 设置响应头
-        responseStream.statusCode = res.statusCode;
-        Object.keys(res.headers).forEach(key => {
-          responseStream.setHeader(key, res.headers[key]);
+        logger.debug(`🌊 Claude stream response status: ${res.statusCode}`);
+
+        // 错误响应处理
+        if (res.statusCode !== 200) {
+          logger.error(`❌ Claude API returned error status: ${res.statusCode}`);
+          let errorData = '';
+          
+          res.on('data', (chunk) => {
+            errorData += chunk.toString();
           });
           
+          res.on('end', () => {
+            logger.error('❌ Claude API error response:', errorData);
+            if (!responseStream.destroyed) {
+              // 发送错误事件
+              responseStream.write('event: error\n');
+              responseStream.write(`data: ${JSON.stringify({ 
+                error: 'Claude API error',
+                status: res.statusCode,
+                details: errorData,
+                timestamp: new Date().toISOString()
+              })}\n\n`);
+              responseStream.end();
+            }
+            reject(new Error(`Claude API error: ${res.statusCode}`));
+          });
+          return;
+        }
+
         let buffer = '';
         let finalUsageReported = false; // 防止重复统计的标志
         let collectedUsageData = {}; // 收集来自不同事件的usage数据
@@ -693,6 +716,7 @@ class ClaudeRelayService {
         
         // 监听数据块，解析SSE并寻找usage信息
         res.on('data', (chunk) => {
+          try {
             const chunkStr = chunk.toString();
             
             buffer += chunkStr;
@@ -702,20 +726,16 @@ class ClaudeRelayService {
             buffer = lines.pop() || ''; // 保留最后的不完整行
             
             // 转发已处理的完整行到客户端
-          if (lines.length > 0) {
+            if (lines.length > 0 && !responseStream.destroyed) {
               const linesToForward = lines.join('\n') + (lines.length > 0 ? '\n' : '');
               // 如果有流转换器，应用转换
               if (streamTransformer) {
                 const transformed = streamTransformer(linesToForward);
                 if (transformed) {
                   responseStream.write(transformed);
-                // 立即刷新数据，确保实时发送
-                if (responseStream.flush) responseStream.flush();
                 }
               } else {
                 responseStream.write(linesToForward);
-              // 立即刷新数据，确保实时发送
-              if (responseStream.flush) responseStream.flush();
               }
             }
           
@@ -764,11 +784,24 @@ class ClaudeRelayService {
               }
             }
           }
+          } catch (error) {
+            logger.error('❌ Error processing stream data:', error);
+            // 发送错误但不破坏流，让它自然结束
+            if (!responseStream.destroyed) {
+              responseStream.write('event: error\n');
+              responseStream.write(`data: ${JSON.stringify({ 
+                error: 'Stream processing error',
+                message: error.message,
+                timestamp: new Date().toISOString()
+              })}\n\n`);
+            }
+          }
         });
         
         res.on('end', async () => {
+          try {
             // 处理缓冲区中剩余的数据
-          if (buffer.trim()) {
+            if (buffer.trim() && !responseStream.destroyed) {
               if (streamTransformer) {
                 const transformed = streamTransformer(buffer);
                 if (transformed) {
@@ -778,7 +811,14 @@ class ClaudeRelayService {
                 responseStream.write(buffer);
               }
             }
+            
+            // 确保流正确结束
+            if (!responseStream.destroyed) {
               responseStream.end();
+            }
+          } catch (error) {
+            logger.error('❌ Error processing stream end:', error);
+          }
           
           // 检查是否捕获到usage数据
           if (!finalUsageReported) {