Upload chat.js

src/router/chat.js

@@ -7,6 +7,7 @@ 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()
 
@@ -121,130 +122,179 @@ async function convertOpenAIToMammouth(openaiRequest, requestId = null) {
       let hasProcessedText = false // 标记是否已处理文本
       let normalImageCount = 0 // 普通图片计数
 
-      // 处理每个图片
-      console.log(`[图片处理开始] 共${imageParts.length}张图片待处理`)
-      for (let imagePartIndex = 0; imagePartIndex < imageParts.length; imagePartIndex++) {
-        const imagePart = imageParts[imagePartIndex]
-        console.log(`[图片处理] 开始处理第${imagePartIndex + 1}张图片 (全局索引: ${currentImageIndex + 1})`)
+      // 处理每个图片 - 使用严格的顺序处理机制
+      console.log(`[图片处理开始] 共${imageParts.length}张图片待处理，开始时间: ${new Date().toISOString()}`)
 
-        try {
-          // 获取图片数据
-          let imageUrl = imagePart.image_url
-          if (typeof imageUrl === 'object' && imageUrl.url) {
-            imageUrl = imageUrl.url
-          }
+      // 创建图片处理队列，确保严格按顺序处理
+      const imageQueue = new ImageProcessingQueue()
+      const imageProcessingPromises = []
 
-          console.log(`[图片处理] 图片${currentImageIndex + 1}类型: ${imageUrl.startsWith('data:image') ? 'Base64' : 'URL'}`)
-
-          // 使用智能上传方法处理图片（支持长图）
-          // 启用preserveOrder=true来确保图片顺序正确
-          let uploadedUrls = []
-          if (imageUrl.startsWith('data:image')) {
-            uploadedUrls = await imageUploader.uploadFromBase64Smart(
-              imageUrl,
-              null,
-              requestId,
-              currentImageIndex,
-              true  // preserveOrder = true，禁用缓存优化以保持顺序
-            )
-          } else {
-            uploadedUrls = await imageUploader.uploadFromUrlSmart(
-              imageUrl,
-              null,
-              requestId,
-              currentImageIndex,
-              true  // preserveOrder = true，禁用缓存优化以保持顺序
-            )
-          }
+      // 为每张图片创建处理任务
+      for (let imagePartIndex = 0; imagePartIndex < imageParts.length; imagePartIndex++) {
+        const imagePart = imageParts[imagePartIndex]
+        const imageGlobalIndex = currentImageIndex + imagePartIndex
 
-          console.log(`[图片处理] 图片${currentImageIndex + 1}上传完成，获得${uploadedUrls.length}个URL`)
+        console.log(`[队列任务] 创建第${imagePartIndex + 1}张图片的处理任务 (全局索引: ${imageGlobalIndex + 1})`)
 
-          // 如果是长图（多个片段），为每个片段创建单独的消息
-          if (uploadedUrls.length > 1) {
-            console.log(`[长图处理] 图片${currentImageIndex + 1}被切割为${uploadedUrls.length}个片段，将按顺序发送`)
+        // 创建图片处理任务
+        const imageProcessor = async () => {
+          const processingStartTime = Date.now()
+          console.log(`[队列执行] 开始处理图片${imageGlobalIndex + 1}，时间: ${new Date().toISOString()}`)
 
-            if (requestId) {
-              logger.logMessageSegmentation(requestId, currentImageIndex, uploadedUrls.length)
+          try {
+            // 获取图片数据
+            let imageUrl = imagePart.image_url
+            if (typeof imageUrl === 'object' && imageUrl.url) {
+              imageUrl = imageUrl.url
             }
 
-            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(`[队列执行] 图片${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，禁用缓存优化以保持顺序
+              )
+            }
 
-              processedMessages.push({
-                content: segmentText || '.',
-                imagesData: [url],
-                documentsData: []
-              })
+            const afterProcessTime = Date.now()
+            const processingDuration = afterProcessTime - beforeProcessTime
 
-              console.log(`[消息生成] 长图片段${segmentIndex + 1}: "${segmentText.substring(0, 50)}..."`)
+            console.log(`[队列执行] 图片${imageGlobalIndex + 1}上传完成，获得${uploadedUrls.length}个URL`)
+            console.log(`[队列执行] 图片${imageGlobalIndex + 1}处理耗时: ${processingDuration}ms`)
+            console.log(`[队列执行] 图片${imageGlobalIndex + 1}完成时间: ${new Date().toISOString()}`)
 
-              if (includeOriginalText) {
-                hasProcessedText = true
-              }
-            })
-          } else {
-            // 普通图片，按顺序存储到结果数组中
-            const imageResult = {
-              index: imagePartIndex,           // 在消息中的位置索引
-              urls: uploadedUrls,
-              originalIndex: currentImageIndex, // 全局图片索引
-              processOrder: normalImageCount    // 处理顺序
+            return {
+              imagePartIndex,
+              imageGlobalIndex,
+              uploadedUrls,
+              processingDuration,
+              processingStartTime,
+              completedTime: afterProcessTime
             }
+          } catch (error) {
+            console.error(`[队列执行] 图片${imageGlobalIndex + 1}处理失败: ${error.message}`)
+            throw error
+          }
+        }
 
-            normalImageResults.push(imageResult)
-            normalImageCount++
+        // 将任务添加到队列
+        const promise = imageQueue.addTask(imagePartIndex, imageProcessor)
+        imageProcessingPromises.push(promise)
+      }
 
-            console.log(`[图片收集] 普通图片${currentImageIndex + 1}已收集`)
-            console.log(`  - 消息位置索引: ${imagePartIndex}`)
-            console.log(`  - 全局图片索引: ${currentImageIndex}`)
-            console.log(`  - 处理顺序: ${normalImageCount}`)
-            console.log(`  - 当前普通图片总数: ${normalImageCount}`)
-          }
+      console.log(`[队列管理] 所有${imageParts.length}个图片任务已添加到队列`)
 
-          currentImageIndex++
-          console.log(`[图片处理] 图片${currentImageIndex}处理成功，继续下一张`)
+      // 等待所有图片处理完成
+      console.log(`[队列管理] 开始等待所有图片处理完成...`)
+      const imageResults = await Promise.all(imageProcessingPromises)
+      console.log(`[队列管理] 所有图片处理完成，共${imageResults.length}个结果`)
 
-        } catch (error) {
-          console.error(`[图片处理错误] 图片${currentImageIndex + 1}处理失败: ${error.message}`)
-          console.log(`[图片处理错误] 跳过图片${currentImageIndex + 1}，继续处理下一张`)
+      // 处理队列返回的结果
+      for (const result of imageResults) {
+        const { imagePartIndex, imageGlobalIndex, uploadedUrls, processingDuration } = result
+
+        console.log(`[结果处理] 处理图片${imageGlobalIndex + 1}的结果，位置索引: ${imagePartIndex}`)
+
+        // 如果是长图（多个片段），为每个片段创建单独的消息
+        if (uploadedUrls.length > 1) {
+          console.log(`[长图处理] 图片${imageGlobalIndex + 1}被切割为${uploadedUrls.length}个片段，将按顺序发送`)
 
           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'
+            logger.logMessageSegmentation(requestId, imageGlobalIndex, uploadedUrls.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}]`
+
+            processedMessages.push({
+              content: segmentText || '.',
+              imagesData: [url],
+              documentsData: []
             })
+
+            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  // 处理耗时
           }
 
-          // 即使处理失败，也要增加索引以保持一致性
-          currentImageIndex++
+          normalImageResults.push(imageResult)
+          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'}`)
         }
       }
 
+      // 更新全局图片索引
+      currentImageIndex += imageParts.length
+
       console.log(`[图片处理完成] 共处理${imageParts.length}张图片，成功收集${normalImageResults.length}张普通图片`)
 
       // 如果有普通图片，按原始顺序创建一个包含所有普通图片的消息
       if (normalImageResults.length > 0) {
-        console.log(`[排序前验证] 收集到${normalImageResults.length}张普通图片`)
+        console.log(`[排序前验证] 收集到${normalImageResults.length}张普通图片，验证时间: ${new Date().toISOString()}`)
         normalImageResults.forEach((result, idx) => {
-          console.log(`  图片${idx + 1}: 消息位置=${result.index}, 全局索引=${result.originalIndex}, 处理顺序=${result.processOrder}`)
+          console.log(`  图片${idx + 1}: 位置=${result.index}, 全局=${result.originalIndex}, 顺序=${result.processOrder}, 耗时=${result.processingDuration}ms, 收集时间=${new Date(result.collectTime).toISOString()}`)
         })
 
         // 按照imagePartIndex排序，确保严格按客户端上传顺序
-        console.log(`[开始排序] 按消息中的位置索引排序...`)
+        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(' -> ')}`)
+
         normalImageResults.sort((a, b) => {
           const result = a.index - b.index
-          console.log(`  比较: 位置${a.index}(图片${a.originalIndex + 1}) vs 位置${b.index}(图片${b.originalIndex + 1}) = ${result}`)
+          console.log(`  比较: 位置${a.index}(全局${a.originalIndex + 1}) vs 位置${b.index}(全局${b.originalIndex + 1}) = ${result}`)
           return result
         })
 
-        console.log(`[排序后验证] 最终图片顺序:`)
+        console.log(`[排序后验证] 最终图片顺序，完成时间: ${new Date().toISOString()}`)
         normalImageResults.forEach((result, idx) => {
-          console.log(`  第${idx + 1}位: 消息位置=${result.index}, 全局索引=${result.originalIndex}, 处理顺序=${result.processOrder}`)
+          console.log(`  第${idx + 1}位: 位置=${result.index}, 全局=${result.originalIndex}, 顺序=${result.processOrder}, 耗时=${result.processingDuration}ms`)
         })
 
         // 验证排序是否正确（检查index是否连续递增）