Upload 4 files

src/lib/errorHandler.js

@@ -0,0 +1,181 @@
+const logger = require('./logger')
+
+/**
+ * 公共错误处理工具类
+ * 提供统一的错误处理和响应格式
+ */
+class ErrorHandler {
+  /**
+   * 处理 API 错误响应
+   * @param {Object} res - Express 响应对象
+   * @param {Error} error - 错误对象
+   * @param {string} requestId - 请求ID
+   * @param {Object} context - 错误上下文信息
+   */
+  static handleApiError(res, error, requestId = null, context = {}) {
+    const errorInfo = this.parseError(error)
+    
+    // 记录错误日志
+    if (requestId) {
+      logger.logError(requestId, 'API_ERROR', errorInfo.message, {
+        ...context,
+        statusCode: errorInfo.statusCode,
+        errorType: errorInfo.type
+      })
+    }
+
+    // 返回错误响应
+    res.status(errorInfo.statusCode).json({
+      error: {
+        message: errorInfo.message,
+        type: errorInfo.type,
+        code: errorInfo.code
+      }
+    })
+  }
+
+  /**
+   * 处理模型调用错误
+   * @param {Object} res - Express 响应对象
+   * @param {Error} error - 错误对象
+   * @param {string} requestId - 请求ID
+   * @param {string} model - 模型名称
+   * @param {boolean} isStream - 是否为流式请求
+   */
+  static handleModelError(res, error, requestId, model, isStream = false) {
+    const errorInfo = this.parseError(error)
+    
+    logger.logError(requestId, 'MODEL_CALL_ERROR', errorInfo.message, {
+      model,
+      isStream,
+      statusCode: errorInfo.statusCode,
+      errorType: errorInfo.type
+    })
+
+    // 特殊处理403错误（使用限制）
+    if (errorInfo.statusCode === 403) {
+      return this.handleRateLimitError(res, requestId, model)
+    }
+
+    // 返回通用错误响应
+    res.status(errorInfo.statusCode).json({
+      error: {
+        message: errorInfo.message,
+        type: errorInfo.type,
+        code: errorInfo.code
+      }
+    })
+  }
+
+  /**
+   * 处理使用限制错误
+   * @param {Object} res - Express 响应对象
+   * @param {string} requestId - 请求ID
+   * @param {string} model - 模型名称
+   */
+  static handleRateLimitError(res, requestId, model) {
+    const errorMessage = `模型 ${model} 已达到使用限制，请稍后再试`
+    
+    logger.logError(requestId, 'RATE_LIMIT_ERROR', errorMessage, {
+      model,
+      statusCode: 429
+    })
+
+    res.status(429).json({
+      error: {
+        message: errorMessage,
+        type: 'rate_limit_exceeded',
+        code: 'rate_limit_exceeded'
+      }
+    })
+  }
+
+  /**
+   * 处理图片上传错误
+   * @param {string} requestId - 请求ID
+   * @param {Error} error - 错误对象
+   * @param {Object} context - 上下文信息
+   */
+  static handleImageUploadError(requestId, error, context = {}) {
+    const errorInfo = this.parseError(error)
+    
+    logger.logError(requestId, 'IMAGE_UPLOAD_ERROR', errorInfo.message, {
+      ...context,
+      errorType: errorInfo.type
+    })
+
+    throw new Error(`图片上传失败: ${errorInfo.message}`)
+  }
+
+  /**
+   * 解析错误对象，提取关键信息
+   * @param {Error} error - 错误对象
+   * @returns {Object} 解析后的错误信息
+   */
+  static parseError(error) {
+    let statusCode = 500
+    let message = '服务器内部错误'
+    let type = 'server_error'
+    let code = 'internal_error'
+
+    if (error.response) {
+      // Axios 错误
+      statusCode = error.response.status || 500
+      message = error.response.data?.message || 
+                error.response.data?.statusMessage || 
+                error.message || 
+                '请求失败'
+      
+      if (statusCode === 403) {
+        type = 'rate_limit_exceeded'
+        code = 'rate_limit_exceeded'
+      } else if (statusCode === 401) {
+        type = 'authentication_error'
+        code = 'invalid_api_key'
+      } else if (statusCode >= 400 && statusCode < 500) {
+        type = 'client_error'
+        code = 'bad_request'
+      }
+    } else if (error.code) {
+      // 系统错误
+      if (error.code === 'ECONNREFUSED') {
+        message = '连接被拒绝'
+        type = 'connection_error'
+        code = 'connection_refused'
+      } else if (error.code === 'ETIMEDOUT') {
+        message = '请求超时'
+        type = 'timeout_error'
+        code = 'request_timeout'
+        statusCode = 408
+      }
+    } else {
+      // 普通错误
+      message = error.message || '未知错误'
+    }
+
+    return {
+      statusCode,
+      message,
+      type,
+      code
+    }
+  }
+
+  /**
+   * 创建标准化错误对象
+   * @param {string} message - 错误消息
+   * @param {number} statusCode - HTTP状态码
+   * @param {string} type - 错误类型
+   * @param {string} code - 错误代码
+   * @returns {Error} 标准化错误对象
+   */
+  static createError(message, statusCode = 500, type = 'server_error', code = 'internal_error') {
+    const error = new Error(message)
+    error.statusCode = statusCode
+    error.type = type
+    error.code = code
+    return error
+  }
+}
+
+module.exports = ErrorHandler

src/lib/imageProcessor.js

@@ -18,13 +18,13 @@ class ImageProcessor {
   /**
    * 检测是否为长图
    * @param {Buffer} imageBuffer - 图片缓冲区
-   * @returns {Promise<{isLongImage: boolean, width: number, height: number}>}
+   * @returns {Promise<{isLongImage: boolean, width: number, height: number, format: string}>}
    */
   async detectLongImage(imageBuffer) {
     try {
       const metadata = await sharp(imageBuffer).metadata()
-      const { width, height } = metadata
-      
+      const { width, height, format } = metadata
+
       if (!width || !height) {
         throw new Error('无法获取图片尺寸信息')
       }
@@ -32,12 +32,13 @@ class ImageProcessor {
       const isLongImage = height > width * this.LONG_IMAGE_RATIO
       const threshold = width * this.LONG_IMAGE_RATIO
 
-      console.log(`[长图检测] 图片尺寸: ${width}x${height}, 阈值: ${threshold}, 判断: ${isLongImage ? '是长图' : '非长图'}`)
+      console.log(`[长图检测] 图片尺寸: ${width}x${height} (${format}), 阈值: ${threshold}, 判断: ${isLongImage ? '是长图' : '非长图'}`)
 
       return {
         isLongImage,
         width,
         height,
+        format,
         ratio: height / width,
         threshold
       }
@@ -93,6 +94,56 @@ class ImageProcessor {
     return regions
   }
 
+  /**
+   * 根据原图格式选择最优输出格式
+   * @param {string} originalFormat - 原图格式
+   * @returns {string} 最优输出格式
+   */
+  getOptimalOutputFormat(originalFormat) {
+    // 格式映射表：原格式 -> 最优输出格式
+    const formatMap = {
+      'jpeg': 'jpeg',
+      'jpg': 'jpeg',
+      'png': 'png',
+      'webp': 'webp',
+      'gif': 'png', // GIF转PNG保持透明度
+      'bmp': 'png', // BMP转PNG减小文件大小
+      'tiff': 'png', // TIFF转PNG兼容性更好
+      'svg': 'png'  // SVG转PNG用于显示
+    }
+
+    return formatMap[originalFormat?.toLowerCase()] || 'png'
+  }
+
+  /**
+   * 应用最优格式转换
+   * @param {Object} sharpInstance - Sharp实例
+   * @param {string} format - 目标格式
+   * @param {Object} options - 格式选项
+   * @returns {Object} 配置后的Sharp实例
+   */
+  applyOptimalFormat(sharpInstance, format, options = {}) {
+    switch (format) {
+      case 'jpeg':
+        return sharpInstance.jpeg({
+          quality: options.quality || 85,
+          progressive: true
+        })
+      case 'png':
+        return sharpInstance.png({
+          compressionLevel: options.compressionLevel || 6,
+          progressive: true
+        })
+      case 'webp':
+        return sharpInstance.webp({
+          quality: options.quality || 80,
+          effort: 4
+        })
+      default:
+        return sharpInstance.png({ compressionLevel: 6 })
+    }
+  }
+
   /**
    * 切割长图为多个片段
    * @param {Buffer} imageBuffer - 原始图片缓冲区
@@ -102,7 +153,7 @@ class ImageProcessor {
   async cropLongImage(imageBuffer, overlap = this.DEFAULT_OVERLAP) {
     try {
       const detection = await this.detectLongImage(imageBuffer)
-      
+
       if (!detection.isLongImage) {
         // 不是长图，返回原图
         return [{
@@ -120,21 +171,26 @@ class ImageProcessor {
         }]
       }
 
-      const { width, height } = detection
+      const { width, height, format } = detection
       const regions = this.calculateCropRegions(width, height, overlap)
       const segments = []
 
-      console.log(`检测到长图 ${width}x${height}，将切割为 ${regions.length} 个片段`)
+      // 选择最优输出格式
+      const outputFormat = this.getOptimalOutputFormat(format)
+
+      console.log(`检测到长图 ${width}x${height} (${format})，将切割为 ${regions.length} 个片段，输出格式: ${outputFormat}`)
 
       for (const region of regions) {
-        const segmentBuffer = await sharp(imageBuffer)
+        const sharpInstance = sharp(imageBuffer)
           .extract({
             left: region.left,
             top: region.top,
             width: region.width,
             height: region.height
           })
-          .png() // 统一输出为PNG格式
+
+        // 应用最优格式
+        const segmentBuffer = await this.applyOptimalFormat(sharpInstance, outputFormat)
           .toBuffer()
 
         segments.push({
@@ -148,6 +204,8 @@ class ImageProcessor {
             originalHeight: height,
             segmentWidth: region.width,
             segmentHeight: region.height,
+            originalFormat: format,
+            outputFormat: outputFormat,
             cropRegion: {
               top: region.top,
               left: region.left,

src/lib/logger.js

@@ -35,28 +35,11 @@ class Logger {
    */
   logRequestStart(method, url, headers = {}, body = {}) {
     const requestId = this.generateRequestId()
-    const timestamp = this.getTimestamp()
-
-    // 提取关键信息，避免记录敏感数据
-    const logData = {
-      请求ID: requestId,
-      时间: timestamp,
-      方法: method,
-      路径: url,
-      用户代理: headers['user-agent'] || '未知',
-      内容类型: headers['content-type'] || '未知',
-      内容长度: headers['content-length'] || '未知',
-      模型: body.model || '未知',
-      消息数量: Array.isArray(body.messages) ? body.messages.length : 0,
-      包含图片: this.detectImages(body.messages),
-      流式请求: body.stream === true
-    }
 
     // 记录到活跃请求映射
     this.activeRequests.set(requestId, {
       startTime: Date.now(),
       requestId,
-      timestamp,
       method,
       url,
       userAgent: headers['user-agent'] || 'unknown',
@@ -68,7 +51,20 @@ class Logger {
       isStream: body.stream === true
     })
 
-    console.log(`[请求开始] ${JSON.stringify(logData)}`)
+    // 使用结构化日志记录请求开始
+    this.log('INFO', 'REQUEST', 'REQUEST_START', '请求开始', {
+      requestId,
+      method,
+      url,
+      userAgent: headers['user-agent'] || 'unknown',
+      contentType: headers['content-type'] || 'unknown',
+      contentLength: headers['content-length'] || 'unknown',
+      model: body.model || 'unknown',
+      messageCount: Array.isArray(body.messages) ? body.messages.length : 0,
+      hasImages: this.detectImages(body.messages),
+      isStream: body.stream === true
+    })
+
     return requestId
   }
 
@@ -259,17 +255,10 @@ class Logger {
    * @param {Object} errorDetails - 错误详情
    */
   logError(requestId, errorType, errorMessage, errorDetails = {}) {
-    const timestamp = this.getTimestamp()
-    const logData = {
-      请求ID: requestId,
-      时间: timestamp,
-      事件: '错误',
-      错误类型: errorType,
-      错误信息: errorMessage,
+    this.log('ERROR', 'APPLICATION', errorType, errorMessage, {
+      requestId,
       ...errorDetails
-    }
-
-    console.error(`[错误] ${JSON.stringify(logData)}`)
+    })
   }
 
   /**

src/lib/uploader.js

@@ -191,8 +191,8 @@ class ImageUploader {
         })
       }
 
-      // 逐个上传切割后的片段
-      for (const segment of segments) {
+      // 并行上传切割后的片段
+      const uploadPromises = segments.map(async (segment) => {
         const segmentName = imageProcessor.generateSegmentName(
           imageName,
           segment.metadata.segmentIndex,
@@ -201,23 +201,49 @@ class ImageUploader {
 
         try {
           const url = await this.uploadImage(segment.buffer, segmentName)
-          uploadedUrls.push(url)
 
           if (requestId) {
             logger.logImageUpload(requestId, imageIndex, segment.metadata.segmentIndex, true, url)
           }
 
           console.log(`片段 ${segment.metadata.segmentIndex + 1}/${segment.metadata.totalSegments} 上传成功: ${url}`)
+          return {
+            url,
+            segmentIndex: segment.metadata.segmentIndex,
+            success: true
+          }
         } catch (error) {
           if (requestId) {
             logger.logImageUpload(requestId, imageIndex, segment.metadata.segmentIndex, false, null, error.message)
           }
-          throw new Error(`片段 ${segment.metadata.segmentIndex + 1} 上传失败: ${error.message}`)
+
+          console.error(`片段 ${segment.metadata.segmentIndex + 1} 上传失败: ${error.message}`)
+          return {
+            error: error.message,
+            segmentIndex: segment.metadata.segmentIndex,
+            success: false
+          }
         }
+      })
+
+      // 等待所有上传完成
+      const uploadResults = await Promise.all(uploadPromises)
+
+      // 检查是否有失败的上传
+      const failedUploads = uploadResults.filter(result => !result.success)
+      if (failedUploads.length > 0) {
+        const failedIndexes = failedUploads.map(result => result.segmentIndex + 1).join(', ')
+        throw new Error(`片段 ${failedIndexes} 上传失败`)
       }
 
-      console.log(`长图切割上传完成，共 ${uploadedUrls.length} 个片段`)
-      return uploadedUrls
+      // 按照片段顺序排序并提取URL
+      const sortedResults = uploadResults
+        .filter(result => result.success)
+        .sort((a, b) => a.segmentIndex - b.segmentIndex)
+        .map(result => result.url)
+
+      console.log(`长图切割并行上传完成，共 ${sortedResults.length} 个片段`)
+      return sortedResults
 
     } catch (error) {
       if (requestId) {