Upload chat.js

src/router/chat.js

@@ -7,7 +7,6 @@ const accountManager = require('../lib/manager')
 const imageUploader = require('../lib/uploader')
 const logger = require('../lib/logger')
 const ErrorHandler = require('../lib/errorHandler')
-const ImageProcessingQueue = require('../lib/imageQueue')
 
 const router = express.Router()
 
@@ -122,207 +121,168 @@ async function convertOpenAIToMammouth(openaiRequest, requestId = null) {
       let hasProcessedText = false // 标记是否已处理文本
       let normalImageCount = 0 // 普通图片计数
 
-      // 处理每个图片 - 使用严格的顺序处理机制
-      console.log(`[图片处理开始] 共${imageParts.length}张图片待处理，开始时间: ${new Date().toISOString()}`)
+      // 处理每个图片 - 严格按顺序处理，确保不会出现顺序混乱
+      console.log(`[图片处理开始] 共${imageParts.length}张图片待处理，将严格按顺序处理`)
 
-      // 创建图片处理队列，确保严格按顺序处理
-      const imageQueue = new ImageProcessingQueue()
-      const imageProcessingPromises = []
-
-      // 为每张图片创建处理任务
       for (let imagePartIndex = 0; imagePartIndex < imageParts.length; imagePartIndex++) {
         const imagePart = imageParts[imagePartIndex]
-        const imageGlobalIndex = currentImageIndex + imagePartIndex
-
-        console.log(`[队列任务] 创建第${imagePartIndex + 1}张图片的处理任务 (全局索引: ${imageGlobalIndex + 1})`)
-
-        // 创建图片处理任务
-        const imageProcessor = async () => {
-          const processingStartTime = Date.now()
-          console.log(`[队列执行] 开始处理图片${imageGlobalIndex + 1}，时间: ${new Date().toISOString()}`)
+        console.log(`[图片处理] 开始处理第${imagePartIndex + 1}张图片 (消息位置: ${imagePartIndex}, 全局索引: ${currentImageIndex + 1})`)
 
-          try {
-            // 获取图片数据
-            let imageUrl = imagePart.image_url
-            if (typeof imageUrl === 'object' && imageUrl.url) {
-              imageUrl = imageUrl.url
-            }
+        try {
+          // 获取图片数据
+          let imageUrl = imagePart.image_url
+          if (typeof imageUrl === 'object' && imageUrl.url) {
+            imageUrl = imageUrl.url
+          }
 
-            console.log(`[队列执行] 图片${imageGlobalIndex + 1}类型: ${imageUrl.startsWith('data:image') ? 'Base64' : 'URL'}`)
-            console.log(`[队列执行] 图片${imageGlobalIndex + 1}URL长度: ${typeof imageUrl === 'string' ? imageUrl.length : 'N/A'}`)
-
-            // 记录处理前的状态
-            const beforeProcessTime = Date.now()
-            console.log(`[队列执行] 图片${imageGlobalIndex + 1}开始上传处理，时间: ${new Date().toISOString()}`)
-
-            // 使用智能上传方法处理图片（支持长图）
-            // 启用preserveOrder=true来确保图片顺序正确
-            let uploadedUrls = []
-            if (imageUrl.startsWith('data:image')) {
-              uploadedUrls = await imageUploader.uploadFromBase64Smart(
-                imageUrl,
-                null,
-                requestId,
-                imageGlobalIndex,
-                true  // preserveOrder = true，禁用缓存优化以保持顺序
-              )
-            } else {
-              uploadedUrls = await imageUploader.uploadFromUrlSmart(
-                imageUrl,
-                null,
-                requestId,
-                imageGlobalIndex,
-                true  // preserveOrder = true，禁用缓存优化以保持顺序
-              )
-            }
+          console.log(`[图片处理] 图片${currentImageIndex + 1}类型: ${imageUrl.startsWith('data:image') ? 'Base64' : 'URL'}`)
+
+          // 使用智能上传方法处理图片（支持长图）
+          let uploadedUrls = []
+          if (imageUrl.startsWith('data:image')) {
+            uploadedUrls = await imageUploader.uploadFromBase64Smart(
+              imageUrl,
+              null,
+              requestId,
+              currentImageIndex,
+              false  // 恢复正常缓存机制
+            )
+          } else {
+            uploadedUrls = await imageUploader.uploadFromUrlSmart(
+              imageUrl,
+              null,
+              requestId,
+              currentImageIndex,
+              false  // 恢复正常缓存机制
+            )
+          }
 
-            const afterProcessTime = Date.now()
-            const processingDuration = afterProcessTime - beforeProcessTime
+          console.log(`[图片处理] 图片${currentImageIndex + 1}上传完成，获得${uploadedUrls.length}个URL，位置索引: ${imagePartIndex}`)
 
-            console.log(`[队列执行] 图片${imageGlobalIndex + 1}上传完成，获得${uploadedUrls.length}个URL`)
-            console.log(`[队列执行] 图片${imageGlobalIndex + 1}处理耗时: ${processingDuration}ms`)
-            console.log(`[队列执行] 图片${imageGlobalIndex + 1}完成时间: ${new Date().toISOString()}`)
+          // 如果是长图（多个片段），为每个片段创建单独的消息
+          if (uploadedUrls.length > 1) {
+            console.log(`[长图处理] 图片${currentImageIndex + 1}被切割为${uploadedUrls.length}个片段，将按顺序发送`)
 
-            return {
-              imagePartIndex,
-              imageGlobalIndex,
-              uploadedUrls,
-              processingDuration,
-              processingStartTime,
-              completedTime: afterProcessTime
+            if (requestId) {
+              logger.logMessageSegmentation(requestId, currentImageIndex, uploadedUrls.length)
             }
-          } catch (error) {
-            console.error(`[队列执行] 图片${imageGlobalIndex + 1}处理失败: ${error.message}`)
-            throw error
-          }
-        }
-
-        // 将任务添加到队列
-        const promise = imageQueue.addTask(imagePartIndex, imageProcessor)
-        imageProcessingPromises.push(promise)
-      }
 
-      console.log(`[队列管理] 所有${imageParts.length}个图片任务已添加到队列`)
+            uploadedUrls.forEach((url, segmentIndex) => {
+              // 只在第一个长图的第一个片段包含原始文本
+              const includeOriginalText = !hasProcessedText && segmentIndex === 0 && combinedText
+              const segmentText = includeOriginalText
+                ? `${combinedText}\n\n[长图片段 ${segmentIndex + 1}/${uploadedUrls.length}]`
+                : `[长图片段 ${segmentIndex + 1}/${uploadedUrls.length}]`
 
-      // 等待所有图片处理完成
-      console.log(`[队列管理] 开始等待所有图片处理完成...`)
-      const imageResults = await Promise.all(imageProcessingPromises)
-      console.log(`[队列管理] 所有图片处理完成，共${imageResults.length}个结果`)
+              processedMessages.push({
+                content: segmentText || '.',
+                imagesData: [url],
+                documentsData: []
+              })
 
-      // 处理队列返回的结果
-      for (const result of imageResults) {
-        const { imagePartIndex, imageGlobalIndex, uploadedUrls, processingDuration } = result
+              console.log(`[消息生成] 长图片段${segmentIndex + 1}: "${segmentText.substring(0, 50)}..."`)
 
-        console.log(`[结果处理] 处理图片${imageGlobalIndex + 1}的结果，位置索引: ${imagePartIndex}`)
+              if (includeOriginalText) {
+                hasProcessedText = true
+              }
+            })
+          } else {
+            // 普通图片，严格按顺序存储到结果数组中
+            const imageResult = {
+              index: imagePartIndex,           // 在消息中的位置索引（关键排序字段）
+              urls: uploadedUrls,
+              originalIndex: currentImageIndex, // 全局图片索引
+              processOrder: normalImageCount    // 处理顺序
+            }
 
-        // 如果是长图（多个片段），为每个片段创建单独的消息
-        if (uploadedUrls.length > 1) {
-          console.log(`[长图处理] 图片${imageGlobalIndex + 1}被切割为${uploadedUrls.length}个片段，将按顺序发送`)
+            normalImageResults.push(imageResult)
+            normalImageCount++
 
-          if (requestId) {
-            logger.logMessageSegmentation(requestId, imageGlobalIndex, uploadedUrls.length)
+            console.log(`[图片收集] 普通图片${currentImageIndex + 1}已收集 (消息位置: ${imagePartIndex}, 处理顺序: ${normalImageCount})，当前共${normalImageCount}张普通图片`)
           }
 
-          uploadedUrls.forEach((url, segmentIndex) => {
-            // 只在第一个长图的第一个片段包含原始文本
-            const includeOriginalText = !hasProcessedText && segmentIndex === 0 && combinedText
-            const segmentText = includeOriginalText
-              ? `${combinedText}\n\n[长图片段 ${segmentIndex + 1}/${uploadedUrls.length}]`
-              : `[长图片段 ${segmentIndex + 1}/${uploadedUrls.length}]`
-
-            processedMessages.push({
-              content: segmentText || '.',
-              imagesData: [url],
-              documentsData: []
+          currentImageIndex++
+        } catch (error) {
+          if (requestId) {
+            logger.logError(requestId, 'IMAGE_PROCESSING_ERROR', error.message, {
+              imageIndex: currentImageIndex,
+              imagePartIndex: imagePartIndex,
+              imageUrl: typeof imagePart.image_url === 'string' ? imagePart.image_url.substring(0, 100) : 'object'
             })
-
-            console.log(`[消息生成] 长图片段${segmentIndex + 1}: "${segmentText.substring(0, 50)}..."`)
-
-            if (includeOriginalText) {
-              hasProcessedText = true
-            }
-          })
-        } else {
-          // 普通图片，按顺序存储��结果数组中
-          const collectTime = Date.now()
-          const imageResult = {
-            index: imagePartIndex,           // 在消息中的位置索引
-            urls: uploadedUrls,
-            originalIndex: imageGlobalIndex, // 全局图片索引
-            processOrder: normalImageCount,   // 处理顺序
-            collectTime: collectTime,         // 收集时间戳
-            processingDuration: processingDuration  // 处理耗时
+          }
+          console.error(`图片处理错误 (位置${imagePartIndex}, 全局${currentImageIndex + 1}):`, error.message)
+
+          // 图片处理失败时，添加一个错误占位符，避免完全跳过
+          const errorPlaceholder = {
+            index: imagePartIndex,
+            urls: [],
+            originalIndex: currentImageIndex,
+            processOrder: normalImageCount,
+            error: true,
+            errorMessage: error.message
           }
 
-          normalImageResults.push(imageResult)
+          normalImageResults.push(errorPlaceholder)
           normalImageCount++
 
-          console.log(`[图片收集] 普通图片${imageGlobalIndex + 1}已收集，收集时间: ${new Date(collectTime).toISOString()}`)
-          console.log(`  - 消息位置索引: ${imagePartIndex}`)
-          console.log(`  - 全局图片索引: ${imageGlobalIndex}`)
-          console.log(`  - 处理顺序: ${normalImageCount}`)
-          console.log(`  - 处理耗时: ${processingDuration}ms`)
-          console.log(`  - 当前普通图片总数: ${normalImageCount}`)
-          console.log(`  - 第一个URL: ${uploadedUrls[0] ? uploadedUrls[0].substring(uploadedUrls[0].lastIndexOf('/') + 1) : 'N/A'}`)
+          console.log(`[图片错误] 图片${currentImageIndex + 1}处理失败，已添加错误占位符`)
+          currentImageIndex++
         }
       }
 
-      // 更新全局图片索引
-      currentImageIndex += imageParts.length
-
       console.log(`[图片处理完成] 共处理${imageParts.length}张图片，成功收集${normalImageResults.length}张普通图片`)
 
-      // 如果有普通图片，按原始顺序创建一个包含所有普通图片的消息
+      // 如果有普通图片，严格按原始顺序创建一个包含所有普通图片的消息
       if (normalImageResults.length > 0) {
-        console.log(`[排序前验证] 收集到${normalImageResults.length}张普通图片，验证时间: ${new Date().toISOString()}`)
+        console.log(`[排序前验证] 收集到${normalImageResults.length}张普通图片`)
         normalImageResults.forEach((result, idx) => {
-          console.log(`  图片${idx + 1}: 位置=${result.index}, 全局=${result.originalIndex}, 顺序=${result.processOrder}, 耗时=${result.processingDuration}ms, 收集时间=${new Date(result.collectTime).toISOString()}`)
+          console.log(`  图片${idx + 1}: 消息位置=${result.index}, 全局索引=${result.originalIndex}, 处理顺序=${result.processOrder}`)
         })
 
-        // 按照imagePartIndex排序，确保严格按客户端上传顺序
-        console.log(`[开始排序] 按消息中的位置索引排序，排序时间: ${new Date().toISOString()}`)
-
-        // 记录排序前的顺序
-        const beforeSort = normalImageResults.map(r => ({pos: r.index, global: r.originalIndex, order: r.processOrder}))
-        console.log(`[排序前顺序] ${beforeSort.map(r => `位置${r.pos}(全局${r.global},顺序${r.order})`).join(' -> ')}`)
-
+        // 严格按照imagePartIndex排序，确保完全按客户端上传顺序
+        console.log(`[开始排序] 严格按消息中的位置索引排序...`)
         normalImageResults.sort((a, b) => {
-          const result = a.index - b.index
-          console.log(`  比较: 位置${a.index}(全局${a.originalIndex + 1}) vs 位置${b.index}(全局${b.originalIndex + 1}) = ${result}`)
-          return result
+          const diff = a.index - b.index
+          console.log(`[排序比较] 位置${a.index} vs 位置${b.index} = ${diff}`)
+          return diff
         })
 
-        console.log(`[排序后验证] 最终图片顺序，完成时间: ${new Date().toISOString()}`)
+        console.log(`[排序后验证] 最终图片顺序:`)
         normalImageResults.forEach((result, idx) => {
-          console.log(`  第${idx + 1}位: 位置=${result.index}, 全局=${result.originalIndex}, 顺序=${result.processOrder}, 耗时=${result.processingDuration}ms`)
+          console.log(`  第${idx + 1}位: 消息位置=${result.index}, 全局索引=${result.originalIndex}, 处理顺序=${result.processOrder}`)
         })
 
-        // 验证排序是否正确（检查index是否连续递增）
-        let sortingValid = true
-        for (let i = 1; i < normalImageResults.length; i++) {
-          if (normalImageResults[i].index <= normalImageResults[i-1].index) {
-            console.error(`[排序错误] 位置${i}: 当前index=${normalImageResults[i].index} <= 前一个index=${normalImageResults[i-1].index}`)
-            sortingValid = false
-          }
-        }
-
-        if (sortingValid) {
-          console.log(`[排序验证] ✅ 图片顺序正确`)
-        } else {
-          console.error(`[排序验证] ❌ 图片顺序存在问题`)
-        }
-
-        // 提取所有URL，保持顺序
+        // 提取所有URL，严格保持顺序，跳过错误的图片
         const orderedImageUrls = []
+        const errorMessages = []
+
         normalImageResults.forEach((result, idx) => {
-          console.log(`[URL提取] 第${idx + 1}张图片(位置${result.index}): ${result.urls.length}个URL`)
-          orderedImageUrls.push(...result.urls)
+          if (result.error) {
+            console.log(`[URL提取] 第${idx + 1}个结果，位置${result.index}，图片处理失败: ${result.errorMessage}`)
+            errorMessages.push(`图片${result.originalIndex + 1}处理失败`)
+          } else {
+            console.log(`[URL提取] 第${idx + 1}个结果，位置${result.index}，添加${result.urls.length}个URL`)
+            orderedImageUrls.push(...result.urls)
+          }
         })
 
         const includeOriginalText = !hasProcessedText && combinedText
-        const normalImageText = includeOriginalText
-          ? `${combinedText}\n\n[包含 ${orderedImageUrls.length} 张图片]`
-          : `[包含 ${orderedImageUrls.length} 张图片]`
+        let normalImageText = includeOriginalText ? combinedText : ''
+
+        // 构建图片状态信息
+        const successCount = orderedImageUrls.length
+        const errorCount = errorMessages.length
+
+        if (successCount > 0 && errorCount > 0) {
+          const statusText = `[包含 ${successCount} 张图片，${errorCount} 张图片处理失败]`
+          normalImageText = normalImageText ? `${normalImageText}\n\n${statusText}` : statusText
+        } else if (successCount > 0) {
+          const statusText = `[包含 ${successCount} 张图片]`
+          normalImageText = normalImageText ? `${normalImageText}\n\n${statusText}` : statusText
+        } else if (errorCount > 0) {
+          const statusText = `[${errorCount} 张图片处理失败]`
+          normalImageText = normalImageText ? `${normalImageText}\n\n${statusText}` : statusText
+        }
 
         processedMessages.push({
           content: normalImageText || '.',
@@ -330,14 +290,8 @@ async function convertOpenAIToMammouth(openaiRequest, requestId = null) {
           documentsData: []
         })
 
-        console.log(`[消息生成] 普通图片批量消息: ${orderedImageUrls.length}张图片，按顺序排列`)
-        console.log(`[最终顺序] ${normalImageResults.map(r => `位置${r.index}(图片${r.originalIndex + 1})`).join(' -> ')}`)
-
-        // 最终验证：确保发送给模型的图片顺序与客户端上传顺序一致
-        console.log(`[最终验证] 发送给模型的图片URL顺序:`)
-        orderedImageUrls.forEach((url, idx) => {
-          console.log(`  第${idx + 1}张: ${url.substring(url.lastIndexOf('/') + 1)}`)
-        })
+        console.log(`[消息生成] 普通图片批量消息: ${successCount}张成功，${errorCount}张失败，严格按顺序排列`)
+        console.log(`[最终顺序验证] 图片顺序: ${normalImageResults.map(r => `位置${r.index}(图片${r.originalIndex + 1}${r.error ? '-失败' : ''})`).join(' -> ')}`)
       }
 
       // 如果没有图片，只有文本
@@ -358,18 +312,9 @@ async function convertOpenAIToMammouth(openaiRequest, requestId = null) {
     }
 
     // 将所有处理后的消息添加到表单
-    console.log(`[消息发送前验证] 共${processedMessages.length}条消息将发送给模型`)
-    processedMessages.forEach((msg, msgIndex) => {
-      console.log(`[消息${msgIndex + 1}] 包含${msg.imagesData.length}张图片`)
-      if (msg.imagesData.length > 0) {
-        msg.imagesData.forEach((imageUrl, imgIndex) => {
-          console.log(`  图片${imgIndex + 1}: ${imageUrl.substring(imageUrl.lastIndexOf('/') + 1)}`)
-        })
-      }
+    processedMessages.forEach(msg => {
       form.append('messages', JSON.stringify(msg))
     })
-
-    console.log(`[最终确认] 所有消息已按正确顺序添加到请求表单`)
   }
 
   return form