Upload 2 files

src/router/chat.js

@@ -5,50 +5,10 @@ const { v4: uuidv4 } = require('uuid')
 const { MODEL_MAPPING, MAMMOUTH_API_URL, AUTH_TOKEN, UNLIMITED_MODELS } = require('../config')
 const accountManager = require('../lib/manager')
 const imageUploader = require('../lib/uploader')
+const logger = require('../lib/logger')
 
 const router = express.Router()
 
-// 图片格式检测和调试函数
-function debugImageFormats(messages, requestId, timestamp) {
-  console.log(`[${timestamp}] 🔍 [${requestId}] === 开始详细图片格式检测 ===`)
-
-  if (!messages || !Array.isArray(messages)) {
-    console.log(`[${timestamp}] ❌ [${requestId}] 消息不是数组格式`)
-    return
-  }
-
-  messages.forEach((msg, msgIndex) => {
-    console.log(`[${timestamp}] 📝 [${requestId}] 消息${msgIndex + 1}:`)
-    console.log(`[${timestamp}] 📝 [${requestId}]   角色: ${msg.role}`)
-    console.log(`[${timestamp}] 📝 [${requestId}]   内容类型: ${Array.isArray(msg.content) ? 'array' : typeof msg.content}`)
-
-    if (Array.isArray(msg.content)) {
-      msg.content.forEach((part, partIndex) => {
-        console.log(`[${timestamp}] 🔍 [${requestId}]   部分${partIndex + 1}:`)
-        console.log(`[${timestamp}] 🔍 [${requestId}]     类型: ${part.type}`)
-        console.log(`[${timestamp}] 🔍 [${requestId}]     键: ${Object.keys(part).join(', ')}`)
-
-        // 检测各种可能的图片格式
-        if (part.type === 'image_url') {
-          console.log(`[${timestamp}] ✅ [${requestId}]     → 标准OpenAI图片格式`)
-        } else if (part.type === 'text' && part.text && part.text.includes('data:image/')) {
-          console.log(`[${timestamp}] ✅ [${requestId}]     → 文本中包含base64图片`)
-        } else if (part.image || part.image_data || part.data) {
-          console.log(`[${timestamp}] ✅ [${requestId}]     → 直接图片数据字段`)
-        } else if (part.type === 'image' || part.type === 'image_base64') {
-          console.log(`[${timestamp}] ✅ [${requestId}]     → 非标准图片类型`)
-        } else {
-          console.log(`[${timestamp}] ❓ [${requestId}]     → 未识别的格式`)
-        }
-      })
-    } else if (typeof msg.content === 'string' && msg.content.includes('data:image/')) {
-      console.log(`[${timestamp}] ✅ [${requestId}]   → 字符串消息中包含base64图片`)
-    }
-  })
-
-  console.log(`[${timestamp}] 🔍 [${requestId}] === 图片格式检测完成 ===`)
-}
-
 // API密钥认证中间件
 const authenticate = (req, res, next) => {
   const authHeader = req.headers.authorization || req.headers.Authorization || req.headers['x-api-key']
@@ -84,7 +44,7 @@ function isUnlimitedModel(model) {
 }
 
 // 将OpenAI格式转换为Mammouth格式
-async function convertOpenAIToMammouth(openaiRequest) {
+async function convertOpenAIToMammouth(openaiRequest, requestId = null) {
   const form = new FormData()
 
   // 模型选择
@@ -109,6 +69,21 @@ async function convertOpenAIToMammouth(openaiRequest) {
   form.append('preprompt', preprompt)
 
   // 处理非system角色的消息
+  let totalImageCount = 0
+
+  // 先统计图片总数用于日志
+  regularMessages.forEach(message => {
+    if (Array.isArray(message.content)) {
+      totalImageCount += message.content.filter(part => part.type === 'image_url').length
+    }
+  })
+
+  if (requestId && totalImageCount > 0) {
+    logger.logImageProcessingStart(requestId, totalImageCount)
+  }
+
+  let currentImageIndex = 0
+
   for (const message of regularMessages) {
     // 处理包含图片的消息
     const imagesData = []
@@ -120,124 +95,48 @@ async function convertOpenAIToMammouth(openaiRequest) {
 
       // 遍历内容部分
       for (const part of message.content) {
-        console.log(`[${new Date().toISOString()}] 🔍 处理消息部分:`, JSON.stringify(part, null, 2))
-
         if (part.type === 'text') {
           textParts.push(part.text)
-          // 检查文本中是否包含base64图片
-          if (part.text && part.text.includes('data:image/')) {
-            console.log(`[${new Date().toISOString()}] 🖼️ 在文本中发现base64图片`)
-            try {
-              const imageId = `img_text_${Date.now()}_${Math.random().toString(36).substr(2, 5)}`
-              console.log(`[${new Date().toISOString()}] 🔄 [${imageId}] 开始处理文本中的base64图片`)
-              const uploadedImageUrls = await imageUploader.uploadFromBase64(part.text)
-              console.log(`[${new Date().toISOString()}] ✅ [${imageId}] 文本中的图片处理完成`)
-
-              if (Array.isArray(uploadedImageUrls)) {
-                imagesData.push(...uploadedImageUrls)
-              } else {
-                imagesData.push(uploadedImageUrls)
-              }
-            } catch (error) {
-              console.error(`[${new Date().toISOString()}] ❌ 处理文本中的图片失败:`, error.message)
-            }
-          }
         } else if (part.type === 'image_url') {
-          const imageId = `img_${Date.now()}_${Math.random().toString(36).substr(2, 5)}`
           try {
-            console.log(`[${new Date().toISOString()}] 🖼️ [${imageId}] 开始处理图片`)
-
             // 获取图片数据
             let imageUrl = part.image_url
             if (typeof imageUrl === 'object' && imageUrl.url) {
               imageUrl = imageUrl.url
             }
 
-            console.log(`[${new Date().toISOString()}] 🔍 [${imageId}] 图片类型: ${imageUrl.startsWith('data:image') ? 'base64' : 'URL'}`)
-            console.log(`[${new Date().toISOString()}] 📏 [${imageId}] 图片源长度: ${imageUrl.length} 字符`)
-
-            // 处理base64图片
+            // 使用智能上传方法处理图片（支持长图）
+            let uploadedUrls = []
             if (imageUrl.startsWith('data:image')) {
-              console.log(`[${new Date().toISOString()}] 🔄 [${imageId}] 开始处理base64图片`)
-              const uploadedImageUrls = await imageUploader.uploadFromBase64(imageUrl)
-              console.log(`[${new Date().toISOString()}] ✅ [${imageId}] base64图片处理完成，返回${Array.isArray(uploadedImageUrls) ? uploadedImageUrls.length : 1}个URL`)
-
-              // 智能处理可能返回多个URL（裁切后的图片）
-              if (Array.isArray(uploadedImageUrls)) {
-                imagesData.push(...uploadedImageUrls)
-              } else {
-                imagesData.push(uploadedImageUrls)
-              }
+              uploadedUrls = await imageUploader.uploadFromBase64Smart(
+                imageUrl,
+                null,
+                requestId,
+                currentImageIndex
+              )
             } else {
-              // 处理URL图片
-              console.log(`[${new Date().toISOString()}] 🔄 [${imageId}] 开始处理URL图片`)
-              const uploadedImageUrls = await imageUploader.uploadFromUrl(imageUrl)
-              console.log(`[${new Date().toISOString()}] ✅ [${imageId}] URL图片处理完成，返回${Array.isArray(uploadedImageUrls) ? uploadedImageUrls.length : 1}个URL`)
-
-              // 智能处理可能返回多个URL（裁切后的图片）
-              if (Array.isArray(uploadedImageUrls)) {
-                imagesData.push(...uploadedImageUrls)
-              } else {
-                imagesData.push(uploadedImageUrls)
-              }
-            }
-          } catch (error) {
-            console.error(`[${new Date().toISOString()}] ❌ [${imageId}] 图片处理错误:`, error.message)
-            console.error(`[${new Date().toISOString()}] 🔍 [${imageId}] 错误堆栈:`, error.stack?.split('\n')[0] || 'No stack trace')
-          }
-        } else if (part.type === 'image' || part.type === 'image_base64') {
-          // 处理非标准格式的图片
-          const imageId = `img_alt_${Date.now()}_${Math.random().toString(36).substr(2, 5)}`
-          try {
-            console.log(`[${new Date().toISOString()}] 🖼️ [${imageId}] 处理非标准格式图片: ${part.type}`)
-
-            let imageData = part.image || part.image_data || part.data || part.url
-            if (imageData) {
-              if (imageData.startsWith('data:image')) {
-                const uploadedImageUrls = await imageUploader.uploadFromBase64(imageData)
-                if (Array.isArray(uploadedImageUrls)) {
-                  imagesData.push(...uploadedImageUrls)
-                } else {
-                  imagesData.push(uploadedImageUrls)
-                }
-              } else {
-                const uploadedImageUrls = await imageUploader.uploadFromUrl(imageData)
-                if (Array.isArray(uploadedImageUrls)) {
-                  imagesData.push(...uploadedImageUrls)
-                } else {
-                  imagesData.push(uploadedImageUrls)
-                }
-              }
+              uploadedUrls = await imageUploader.uploadFromUrlSmart(
+                imageUrl,
+                null,
+                requestId,
+                currentImageIndex
+              )
             }
+
+            // 将所有上传的URL添加到imagesData中
+            // 对于长图，这将包含多个片段的URL
+            imagesData.push(...uploadedUrls)
+
+            currentImageIndex++
           } catch (error) {
-            console.error(`[${new Date().toISOString()}] ❌ [${imageId}] 非标准格式图片处理错误:`, error.message)
-          }
-        } else if (part.image || part.image_data || part.data) {
-          // 处理直接包含图片数据的情况
-          const imageId = `img_direct_${Date.now()}_${Math.random().toString(36).substr(2, 5)}`
-          try {
-            console.log(`[${new Date().toISOString()}] 🖼️ [${imageId}] 处理直接图片数据`)
-
-            let imageData = part.image || part.image_data || part.data
-            if (typeof imageData === 'string') {
-              if (imageData.startsWith('data:image')) {
-                const uploadedImageUrls = await imageUploader.uploadFromBase64(imageData)
-                if (Array.isArray(uploadedImageUrls)) {
-                  imagesData.push(...uploadedImageUrls)
-                } else {
-                  imagesData.push(uploadedImageUrls)
-                }
-              } else {
-                const uploadedImageUrls = await imageUploader.uploadFromUrl(imageData)
-                if (Array.isArray(uploadedImageUrls)) {
-                  imagesData.push(...uploadedImageUrls)
-                } else {
-                  imagesData.push(uploadedImageUrls)
-                }
-              }
+            if (requestId) {
+              logger.logError(requestId, 'IMAGE_PROCESSING_ERROR', error.message, {
+                imageIndex: currentImageIndex,
+                imageUrl: typeof part.image_url === 'string' ? part.image_url.substring(0, 100) : 'object'
+              })
             }
-          } catch (error) {
-            console.error(`[${new Date().toISOString()}] ❌ [${imageId}] 直接图片数据处理错误:`, error.message)
+            console.error('图片处理错误:', error.message)
+            currentImageIndex++
           }
         }
       }
@@ -255,41 +154,20 @@ async function convertOpenAIToMammouth(openaiRequest) {
       imagesData: imagesData,
       documentsData: []
     }))
-
-    console.log(`[${new Date().toISOString()}] 📊 消息处理完成 - 文本内容: ${content.length}字符, 图片数量: ${imagesData.length}`)
   }
 
-  // 统计总图片数
-  let totalImages = 0
-  regularMessages.forEach(message => {
-    if (Array.isArray(message.content)) {
-      message.content.forEach(part => {
-        if (part.type === 'image_url' || part.image || part.image_data || part.data) {
-          totalImages++
-        }
-      })
-    }
-  })
-
-  console.log(`[${new Date().toISOString()}] 🎯 请求转换完成`)
-  console.log(`[${new Date().toISOString()}] 📊 统计信息:`)
-  console.log(`[${new Date().toISOString()}]   - 总消息数: ${regularMessages.length}`)
-  console.log(`[${new Date().toISOString()}]   - 检测到的图片数: ${totalImages}`)
-  console.log(`[${new Date().toISOString()}]   - 模型: ${form._streams ? form._streams.find(s => s[0] === 'model')?.[1] : '未知'}`)
-  console.log(`[${new Date().toISOString()}]   - FormData类型: ${form.getHeaders ? 'valid' : 'invalid'}`)
-
   return form
 }
 
 // 处理流数据
-async function handleStreamResponse(axiosResponse, res, requestedModel) {
-  const requestId = uuidv4()
+async function handleStreamResponse(axiosResponse, res, requestedModel, logRequestId = null) {
+  const responseId = uuidv4()
   const timestamp = Math.floor(Date.now() / 1000)
   const decoder = new TextDecoder()
 
   // 发送初始角色数据
   res.write(`data: ${JSON.stringify({
-    id: `chatcmpl-${requestId}`,
+    id: `chatcmpl-${responseId}`,
     object: "chat.completion.chunk",
     created: timestamp,
     model: requestedModel,
@@ -307,7 +185,7 @@ async function handleStreamResponse(axiosResponse, res, requestedModel) {
     const textToSend = chunkStr
     if (textToSend) {
       res.write(`data: ${JSON.stringify({
-        id: `chatcmpl-${requestId}`,
+        id: `chatcmpl-${responseId}`,
         object: "chat.completion.chunk",
         created: timestamp,
         model: requestedModel,
@@ -323,7 +201,7 @@ async function handleStreamResponse(axiosResponse, res, requestedModel) {
   axiosResponse.data.on('end', () => {
     // 发送完成信号
     res.write(`data: ${JSON.stringify({
-      id: `chatcmpl-${requestId}`,
+      id: `chatcmpl-${responseId}`,
       object: "chat.completion.chunk",
       created: timestamp,
       model: requestedModel,
@@ -339,14 +217,19 @@ async function handleStreamResponse(axiosResponse, res, requestedModel) {
   })
 
   axiosResponse.data.on('error', (err) => {
+    if (logRequestId) {
+      logger.logError(logRequestId, 'STREAM_ERROR', err.message, {
+        model: requestedModel
+      })
+    }
     console.error('流数据处理错误:', err)
     res.status(500).end()
   })
 }
 
 // 处理非流数据
-function handleNonStreamResponse(axiosResponse, res, requestedModel) {
-  const requestId = uuidv4()
+function handleNonStreamResponse(axiosResponse, res, requestedModel, logRequestId = null) {
+  const responseId = uuidv4()
   const timestamp = Math.floor(Date.now() / 1000)
 
   // 格式化为OpenAI的响应格式
@@ -357,20 +240,8 @@ function handleNonStreamResponse(axiosResponse, res, requestedModel) {
     content = content.slice(1, -1);
   }
 
-  // 安全地处理内容，避免循环引用
-  let safeContent = content
-  if (!safeContent) {
-    if (typeof axiosResponse.data === 'string') {
-      safeContent = axiosResponse.data
-    } else if (axiosResponse.data && axiosResponse.data.message) {
-      safeContent = axiosResponse.data.message
-    } else {
-      safeContent = "响应内容为空"
-    }
-  }
-
   const responseData = {
-    id: `chatcmpl-${requestId}`,
+    id: `chatcmpl-${responseId}`,
     object: "chat.completion",
     created: timestamp,
     model: requestedModel,
@@ -378,7 +249,7 @@ function handleNonStreamResponse(axiosResponse, res, requestedModel) {
       index: 0,
       message: {
         role: "assistant",
-        content: safeContent
+        content: content || axiosResponse.data
       },
       finish_reason: "stop"
     }],
@@ -423,116 +294,40 @@ async function retryWithNewCookie(req, res, config, currentCookie, requestedMode
 
 // OpenAI兼容的聊天完成API接口，使用中间件验证API密钥
 router.post('/completions', authenticate, async (req, res) => {
-  const timestamp = new Date().toISOString()
-  const requestId = require('uuid').v4().substring(0, 8)
+  let requestId = null
+  const startTime = Date.now()
 
   try {
     const openaiRequest = req.body
-
-    // 检查请求体是否存在
-    if (!openaiRequest) {
-      console.error(`[${timestamp}] ❌ [${requestId}] 请求体为空`)
-      return res.status(400).json({
-        error: {
-          message: '请求体为空',
-          type: 'invalid_request_error',
-          code: 'missing_body'
-        }
-      })
-    }
-
     const isStreamRequest = openaiRequest.stream === true
     const requestedModel = openaiRequest.model
 
-    console.log(`[${timestamp}] 🎯 [${requestId}] 开始处理聊天请求`)
-    console.log(`[${timestamp}] 📊 [${requestId}] 模型: ${requestedModel}`)
-    console.log(`[${timestamp}] 🌊 [${requestId}] 流式: ${isStreamRequest ? '是' : '否'}`)
-    console.log(`[${timestamp}] 💬 [${requestId}] 消息数量: ${openaiRequest.messages?.length || 0}`)
-
-    // 调试：输出原始请求体结构
-    console.log(`[${timestamp}] 🐛 [${requestId}] 请求体类型: ${typeof openaiRequest}`)
-    console.log(`[${timestamp}] 🐛 [${requestId}] 请求体键: ${Object.keys(openaiRequest || {}).join(', ')}`)
-    if (openaiRequest.messages) {
-      console.log(`[${timestamp}] 🐛 [${requestId}] 消息结构预览:`)
-      openaiRequest.messages.forEach((msg, i) => {
-        console.log(`[${timestamp}] 🐛 [${requestId}]   消息${i}: role=${msg.role}, content类型=${Array.isArray(msg.content) ? 'array' : typeof msg.content}`)
-      })
-
-      // 详细的图片格式检测
-      debugImageFormats(openaiRequest.messages, requestId, timestamp)
-    }
-
-    // 检查是否包含图片 - 增强检测逻辑
-    let hasImages = false
-    let imageCount = 0
-    console.log(`[${timestamp}] 🔍 [${requestId}] 开始检查消息中的图片`)
-
-    if (openaiRequest.messages) {
-      openaiRequest.messages.forEach((msg, msgIndex) => {
-        console.log(`[${timestamp}] 📝 [${requestId}] 消息${msgIndex + 1} - 角色: ${msg.role}`)
-        console.log(`[${timestamp}] 📝 [${requestId}] 消息${msgIndex + 1} - 内容类型: ${Array.isArray(msg.content) ? '数组' : typeof msg.content}`)
-
-        if (Array.isArray(msg.content)) {
-          msg.content.forEach((part, partIndex) => {
-            console.log(`[${timestamp}] 🔍 [${requestId}] 消息${msgIndex + 1}-部分${partIndex + 1} - 类型: ${part.type}`)
-            console.log(`[${timestamp}] 🔍 [${requestId}] 消息${msgIndex + 1}-部分${partIndex + 1} - 完整内容:`, JSON.stringify(part, null, 2))
-
-            // 标准OpenAI格式检测
-            if (part.type === 'image_url') {
-              hasImages = true
-              imageCount++
-              console.log(`[${timestamp}] 🖼️ [${requestId}] 发现标准格式图片${imageCount}: ${part.image_url?.url ? part.image_url.url.substring(0, 50) + '...' : '无URL'}`)
-            }
-            // 检测其他可能的图片格式
-            else if (part.type === 'image' || part.type === 'image_base64') {
-              hasImages = true
-              imageCount++
-              console.log(`[${timestamp}] 🖼️ [${requestId}] 发现非标准格式图片${imageCount}: 类型=${part.type}`)
-            }
-            // 检测文本中是否包含base64图片
-            else if (part.type === 'text' && part.text && typeof part.text === 'string' && part.text.includes('data:image/')) {
-              hasImages = true
-              imageCount++
-              console.log(`[${timestamp}] 🖼️ [${requestId}] 在文本部分发现base64图片${imageCount}`)
-            }
-            // 检测是否有直接的图片数据字段
-            else if (part.image || part.image_data || part.data) {
-              hasImages = true
-              imageCount++
-              console.log(`[${timestamp}] 🖼️ [${requestId}] 发现直接图片数据${imageCount}`)
-            }
-          })
-        } else if (typeof msg.content === 'string') {
-          // 检查字符串内容是否包含base64图片
-          if (msg.content.includes('data:image/')) {
-            console.log(`[${timestamp}] 🖼️ [${requestId}] 在字符串消息中发���base64图片`)
-            hasImages = true
-            imageCount++
-          }
-        }
-      })
-    }
-
-    console.log(`[${timestamp}] 📊 [${requestId}] 图片检查结果: ${hasImages ? `发现${imageCount}张图片` : '未发现图片'}`)
+    // 记录请求开始
+    requestId = logger.logRequestStart(
+      req.method,
+      req.originalUrl,
+      req.headers,
+      openaiRequest
+    )
 
     // 设置适当的响应头
     if (isStreamRequest) {
       res.setHeader('Content-Type', 'text/event-stream')
       res.setHeader('Cache-Control', 'no-cache')
       res.setHeader('Connection', 'keep-alive')
-      console.log(`[${timestamp}] 🌊 [${requestId}] 设置流式响应头`)
     }
 
     // 转换请求格式
-    console.log(`[${timestamp}] 🔄 [${requestId}] 开始转换请求格式`)
-    const form = await convertOpenAIToMammouth(openaiRequest)
-    console.log(`[${timestamp}] ✅ [${requestId}] 请求格式转换完成`)
+    const form = await convertOpenAIToMammouth(openaiRequest, requestId)
 
     // 获取Cookie - 根据模型类型使用不同的获取方法
     const cookieValue = isUnlimitedModel(requestedModel)
       ? accountManager.getAnyCookie()
       : accountManager.getNextAvailableCookie()
-    console.log(`[${timestamp}] 🍪 [${requestId}] 使用账号: ${cookieValue ? cookieValue.substring(0, 8) + '...' : '无可用账号'}`)
+
+    // 记录模型调用开始
+    const mammouthModel = MODEL_MAPPING[requestedModel] || requestedModel
+    logger.logModelCallStart(requestId, requestedModel, mammouthModel)
 
     // 准备请求配置
     const config = {
@@ -549,82 +344,51 @@ router.post('/completions', authenticate, async (req, res) => {
 
     try {
       // 发送请求到Mammouth API
-      console.log(`[${timestamp}] 🚀 [${requestId}] 发送请求到Mammouth API`)
-      console.log(`[${timestamp}] 🌐 [${requestId}] 请求URL: ${config.url}`)
-      console.log(`[${timestamp}] 📋 [${requestId}] 请求方法: ${config.method}`)
-      console.log(`[${timestamp}] 🍪 [${requestId}] Cookie: ${cookieValue ? cookieValue.substring(0, 8) + '...' : '无'}`)
-
-      // 记录FormData的基本信息（不记录具体内容避免日志过长）
-      if (form && form.getHeaders) {
-        const headers = form.getHeaders()
-        console.log(`[${timestamp}] 📦 [${requestId}] FormData Content-Type: ${headers['content-type']?.substring(0, 50)}...`)
-      }
-
+      const modelCallStartTime = Date.now()
       const response = await axios(config)
-      console.log(`[${timestamp}] ✅ [${requestId}] Mammouth API响应成功`)
-      console.log(`[${timestamp}] 📊 [${requestId}] 响应状态: ${response.status}`)
-
-      // 安全地计算响应大小
-      let responseSize = 'unknown'
-      try {
-        if (typeof response.data === 'string') {
-          responseSize = response.data.length
-        } else if (response.data && typeof response.data === 'object') {
-          responseSize = 'object'
-        }
-      } catch (error) {
-        responseSize = 'cannot_measure'
-      }
-      console.log(`[${timestamp}] 📏 [${requestId}] 响应大小: ${responseSize} 字符`)
+      const modelCallDuration = Date.now() - modelCallStartTime
+
+      // 记录模型调用成功
+      logger.logModelCallEnd(requestId, true, null, modelCallDuration)
 
       // 处理响应
       if (isStreamRequest) {
-        console.log(`[${timestamp}] 🌊 [${requestId}] 开始处理流式响应`)
-        handleStreamResponse(response, res, requestedModel)
+        handleStreamResponse(response, res, requestedModel, requestId)
       } else {
-        console.log(`[${timestamp}] 📄 [${requestId}] 开始处理非流式响应`)
-        handleNonStreamResponse(response, res, requestedModel)
+        handleNonStreamResponse(response, res, requestedModel, requestId)
       }
+
+      // 记录请求成功结束
+      logger.logRequestEnd(requestId, 200, {
+        responseType: isStreamRequest ? 'stream' : 'json',
+        totalDuration: Date.now() - startTime
+      })
+
+    } catch (error) {
     } catch (error) {
+      // 记录模型调用失败
+      const modelCallDuration = Date.now() - startTime
+      logger.logModelCallEnd(requestId, false, error.message, modelCallDuration)
+
       // 优化错误日志打印，只打印关键信息
       const errorStatus = error.response?.status || 'unknown'
       const errorMessage = error.response?.data?.message || error.message || 'Unknown error'
-      const errorData = error.response?.data || 'No response data'
-
-      console.error(`[${timestamp}] ❌ [${requestId}] API转发错误: [${errorStatus}] ${errorMessage}`)
-      console.error(`[${timestamp}] 🔍 [${requestId}] 错误详情: ${error.stack?.split('\n')[0] || 'No stack trace'}`)
-
-      // 安全地记录响应数据，避免循环引用
-      try {
-        if (typeof errorData === 'string') {
-          console.error(`[${timestamp}] 📋 [${requestId}] 响应数据: ${errorData}`)
-        } else if (errorData && typeof errorData === 'object') {
-          // 只记录基本属性，避免循环引用
-          const safeErrorData = {
-            message: errorData.message,
-            error: errorData.error,
-            status: errorData.status,
-            code: errorData.code
-          }
-          console.error(`[${timestamp}] 📋 [${requestId}] 响应数据:`, JSON.stringify(safeErrorData, null, 2))
-        }
-      } catch (jsonError) {
-        console.error(`[${timestamp}] 📋 [${requestId}] 响应数据: [无法序列化]`)
-      }
 
-      console.error(`[${timestamp}] 🌐 [${requestId}] 请求URL: ${config.url}`)
-      console.error(`[${timestamp}] 🍪 [${requestId}] 使用的Cookie: ${cookieValue ? cookieValue.substring(0, 8) + '...' : '无'}`)
+      // 记录详细错误信息
+      logger.logError(requestId, 'MODEL_CALL_ERROR', errorMessage, {
+        status: errorStatus,
+        model: requestedModel,
+        isStream: isStreamRequest,
+        cookieUsed: cookieValue?.substring(0, 8) + '...'
+      })
 
-      // 如果是图片相关的错误，记录图片信息
-      if (hasImages) {
-        console.error(`[${timestamp}] 🖼️ [${requestId}] 图片处理信息: 包含${imageCount}张图片`)
-      }
+      console.error(`API转发错误: [${errorStatus}] ${errorMessage}`)
 
       // 如果是403错误（达到使用限制）
       if (error.response && error.response.status === 403) {
         // console.log(error)
 
-        console.log(`[${timestamp}] 🚫 [${requestId}] 账号 ${cookieValue.substring(0, 5)}... 使用模型 ${requestedModel} 已达到使用限制`)
+        console.log(`账号 ${cookieValue.substring(0, 5)}... 使用模型 ${requestedModel} 已达到使用限制`)
 
         // 根据模型类型进行不同处理
         if (isUnlimitedModel(requestedModel)) {
@@ -741,6 +505,11 @@ router.post('/completions', authenticate, async (req, res) => {
         }
       } else {
         // 其他错误
+        logger.logRequestEnd(requestId, 500, {
+          error: error.message,
+          totalDuration: Date.now() - startTime
+        })
+
         res.status(500).json({
           error: {
             message: '处理请求时发生错误',
@@ -751,6 +520,17 @@ router.post('/completions', authenticate, async (req, res) => {
       }
     }
   } catch (error) {
+    // 记录最终错误
+    if (requestId) {
+      logger.logError(requestId, 'REQUEST_ERROR', error.message, {
+        totalDuration: Date.now() - startTime
+      })
+      logger.logRequestEnd(requestId, 500, {
+        error: error.message,
+        totalDuration: Date.now() - startTime
+      })
+    }
+
     console.error('请求处理错误:', error)
     res.status(500).json({
       error: {