Update handlers.go

handlers.go

@@ -9,6 +9,7 @@ import (
 	"net"
 	"net/http"
 	"net/url"
+	"os" // Thêm os để sử dụng os.Getenv
 	"strings"
 	"time"
 
@@ -16,42 +17,52 @@ import (
 	"github.com/google/uuid"
 )
 
+const (
+	// ANTHROPIC_VERSION_ENV_VAR là tên biến môi trường để lấy phiên bản Anthropic
+	ANTHROPIC_VERSION_ENV_VAR = "ANTHROPIC_VERSION"
+	// DEFAULT_ANTHROPIC_VERSION là phiên bản Anthropic mặc định nếu không được đặt trong biến môi trường
+	DEFAULT_ANTHROPIC_VERSION = "2023-06-01"
+)
+
+// maskURL che giấu hostname trong URL để bảo mật log.
+// Ví dụ: "https://api.example.com/v1" -> "https://api******.com/v1"
 func maskURL(rawURL string) string {
 	u, err := url.Parse(rawURL)
 	if err != nil {
-		return rawURL
+		return rawURL // Trả về URL gốc nếu không parse được
 	}
 
 	originalHostname := u.Hostname()
 	if originalHostname == "" {
-		return rawURL
+		return rawURL // Không có hostname để che
 	}
 
+	// Không che giấu địa chỉ IP
 	if net.ParseIP(originalHostname) != nil {
 		return rawURL
 	}
 
 	hostParts := strings.Split(originalHostname, ".")
 	maskedHostname := ""
-	prefixToKeepLength := 3
+	prefixToKeepLength := 3 // Số ký tự đầu tiên của phần tên miền chính giữ lại
 
-	if len(hostParts) == 1 {
+	if len(hostParts) == 1 { // ví dụ: "localhost"
 		nameOnly := hostParts[0]
 		prefix := nameOnly
 		if len(nameOnly) > prefixToKeepLength {
 			prefix = nameOnly[:prefixToKeepLength]
 		}
 		maskedHostname = prefix + "******"
-	} else if len(hostParts) >= 2 {
-		tld := hostParts[len(hostParts)-1]
-		namePart := strings.Join(hostParts[:len(hostParts)-1], ".")
+	} else if len(hostParts) >= 2 { // ví dụ: "api.example.com"
+		tld := hostParts[len(hostParts)-1]                     // "com"
+		namePart := strings.Join(hostParts[:len(hostParts)-1], ".") // "api.example"
 
 		prefix := namePart
 		if len(namePart) > prefixToKeepLength {
 			prefix = namePart[:prefixToKeepLength]
 		}
 		maskedHostname = prefix + "******" + "." + tld
-	} else {
+	} else { // Trường hợp không mong muốn, che toàn bộ
 		maskedHostname = "******"
 	}
 
@@ -60,33 +71,35 @@ func maskURL(rawURL string) string {
 		newHost += ":" + u.Port()
 	}
 
-	maskedU := *u
+	maskedU := *u // Tạo bản sao của URL
 	maskedU.Host = newHost
 
 	return maskedU.String()
 }
 
+// HealthCheckHandler xử lý kiểm tra tình trạng của proxy.
 func HealthCheckHandler(c *gin.Context) {
 	c.JSON(http.StatusOK, gin.H{"status": "healthy"})
 }
 
+// MessagesHandler xử lý các yêu cầu đến /v1/messages.
+// Nó chuyển đổi yêu cầu từ định dạng Claude sang OpenAI (nếu cần),
+// gửi đến upstream API, và chuyển đổi phản hồi trở lại định dạng Claude.
 func MessagesHandler(c *gin.Context) {
-	requestID := fmt.Sprintf("msg_%s", uuid.NewString()[:24])
-	cfg := LoadConfig()
+	requestID := fmt.Sprintf("msg_%s", uuid.NewString()[:24]) // Tạo ID duy nhất cho mỗi yêu cầu
+	cfg := LoadConfig()                                      // Tải cấu hình (có thể tối ưu hóa để không tải mỗi lần)
 	startTime := time.Now()
 
 	var claudeReq ClaudeRequest
 	bodyBytes, err := io.ReadAll(c.Request.Body)
 	if err != nil {
-		// Giữ lại: Log lỗi quan trọng
 		log.Printf("ERROR: [%s] Không thể đọc nội dung yêu cầu: %v", requestID, err)
 		sendClaudeError(c, http.StatusBadRequest, "invalid_request_error", "Không thể đọc nội dung yêu cầu.")
 		return
 	}
-	c.Request.Body = io.NopCloser(bytes.NewBuffer(bodyBytes)) // Restore request body
+	c.Request.Body = io.NopCloser(bytes.NewBuffer(bodyBytes)) // Khôi phục body để có thể đọc lại nếu cần
 
 	if err := json.Unmarshal(bodyBytes, &claudeReq); err != nil {
-		// Giữ lại: Log lỗi quan trọng
 		log.Printf("ERROR: [%s] Không thể giải mã JSON yêu cầu: %v. Body: %s", requestID, err, string(bodyBytes))
 		sendClaudeError(c, http.StatusBadRequest, "invalid_request_error", "Định dạng JSON không hợp lệ trong nội dung yêu cầu.")
 		return
@@ -95,80 +108,89 @@ func MessagesHandler(c *gin.Context) {
 	isStreaming := claudeReq.Stream
 	modelRequested := claudeReq.Model
 	if modelRequested == "" {
-		modelRequested = "unknown_model"
+		modelRequested = "unknown_model" // Đặt tên model mặc định nếu client không cung cấp
 	}
-	// Giữ lại: Log INFO quan trọng về yêu cầu nhận được
 	log.Printf("INFO: [%s] Nhận yêu cầu. Stream: %t, Model: %s, ClientIP: %s, NativeClaude: %t",
 		requestID, isStreaming, modelRequested, c.ClientIP(), cfg.UpstreamNativeClaudeFormat)
 
 	var upstreamURL string
 	var upstreamRequestBodyBytes []byte
-	var openAIReqForLogging *OpenAIRequest // Only used if not native claude, for logging model
+	var openAIReqForLogging *OpenAIRequest // Chỉ dùng để log model nếu không phải native Claude
 
 	if cfg.UpstreamNativeClaudeFormat {
-		// Upstream expects Claude format
-		upstreamURL = strings.TrimRight(cfg.OpenAIAPIEndpoint, "/") + "/v1/messages" // Standard Claude endpoint path
-		upstreamRequestBodyBytes = bodyBytes                                        // Use original Claude request body
-		// Giữ lại: Log INFO
+		// Upstream API hỗ trợ định dạng Claude native
+		upstreamURL = strings.TrimRight(cfg.OpenAIAPIEndpoint, "/") + "/v1/messages" // Đường dẫn chuẩn của Claude API
+		upstreamRequestBodyBytes = bodyBytes                                        // Sử dụng body gốc của Claude
 		log.Printf("INFO: [%s] Upstream là Claude native. Chuyển tiếp yêu cầu gốc đến %s", requestID, maskURL(upstreamURL))
 	} else {
-		// Upstream expects OpenAI format, convert
-		upstreamURL = strings.TrimRight(cfg.OpenAIAPIEndpoint, "/") + "/v1/chat/completions" // Standard OpenAI endpoint path
+		// Upstream API là OpenAI hoặc tương thích OpenAI, cần chuyển đổi
+		upstreamURL = strings.TrimRight(cfg.OpenAIAPIEndpoint, "/") + "/v1/chat/completions" // Đường dẫn chuẩn của OpenAI API
 		openAIReq, errConv := convertClaudeRequestToOpenAI(&claudeReq)
 		if errConv != nil {
-			// Giữ lại: Log lỗi quan trọng
 			log.Printf("ERROR: [%s] Không thể chuyển đổi yêu cầu Claude sang OpenAI: %v", requestID, errConv)
 			sendClaudeError(c, http.StatusBadRequest, "invalid_request_error", fmt.Sprintf("Lỗi chuyển đổi dữ liệu yêu cầu: %v", errConv))
 			return
 		}
-		openAIReq.Stream = isStreaming // Ensure stream flag is set correctly
-		openAIReqForLogging = openAIReq // Store for logging model used in SSE
+		openAIReq.Stream = isStreaming // Đảm bảo cờ stream được đặt chính xác
+		openAIReqForLogging = openAIReq // Lưu lại để log model được sử dụng trong SSE
 
 		openaiReqBytesMarshal, errMarshal := json.Marshal(openAIReq)
 		if errMarshal != nil {
-			// Giữ lại: Log lỗi quan trọng
 			log.Printf("ERROR: [%s] Không thể marshal yêu cầu OpenAI JSON: %v", requestID, errMarshal)
 			sendClaudeError(c, http.StatusInternalServerError, "internal_server_error", "Không thể chuẩn bị yêu cầu upstream.")
 			return
 		}
 		upstreamRequestBodyBytes = openaiReqBytesMarshal
-		// Giữ lại: Log INFO
 		log.Printf("INFO: [%s] Upstream là OpenAI. Chuyển đổi và gửi yêu cầu đến %s", requestID, maskURL(upstreamURL))
 	}
 
+	// Tạo yêu cầu HTTP mới đến upstream API
 	req, err := http.NewRequestWithContext(c.Request.Context(), "POST", upstreamURL, bytes.NewBuffer(upstreamRequestBodyBytes))
 	if err != nil {
-		// Giữ lại: Log lỗi quan trọng
 		log.Printf("ERROR: [%s] Không thể tạo yêu cầu HTTP upstream: %v", requestID, err)
 		sendClaudeError(c, http.StatusInternalServerError, "internal_server_error", "Không thể tạo yêu cầu upstream.")
 		return
 	}
 
+	// Thiết lập các header cho yêu cầu upstream
 	req.Header.Set("Content-Type", "application/json")
 	if isStreaming {
 		req.Header.Set("Accept", "text/event-stream")
 	} else {
 		req.Header.Set("Accept", "application/json")
 	}
-	if cfg.OpenAIAPIKey != "" {
-		req.Header.Set("Authorization", "Bearer "+cfg.OpenAIAPIKey)
-	}
-	if cfg.UpstreamNativeClaudeFormat {
-		// Add Anthropic-Version header if upstream is native Claude and it's required
-		// Example: req.Header.Set("anthropic-version", "2023-06-01")
-		// For now, this is commented out as it depends on specific upstream requirements.
+
+	// Xử lý xác thực cho upstream API
+	if cfg.OpenAIAPIKey != "" { // Đảm bảo có API key để gửi
+		if cfg.UpstreamNativeClaudeFormat {
+			// Upstream là Claude native, sử dụng x-api-key và anthropic-version
+			req.Header.Set("x-api-key", cfg.OpenAIAPIKey)
+
+			anthropicVersion := os.Getenv(ANTHROPIC_VERSION_ENV_VAR)
+			if anthropicVersion == "" {
+				anthropicVersion = DEFAULT_ANTHROPIC_VERSION // Sử dụng giá trị mặc định nếu không được đặt
+				log.Printf("INFO: [%s] Biến môi trường %s không được đặt, sử dụng phiên bản Anthropic mặc định: %s", requestID, ANTHROPIC_VERSION_ENV_VAR, anthropicVersion)
+			}
+			req.Header.Set("anthropic-version", anthropicVersion)
+			log.Printf("INFO: [%s] Đặt header Anthropic-Version: %s cho upstream Claude native.", requestID, anthropicVersion)
+
+		} else {
+			// Upstream là OpenAI hoặc tương thích OpenAI, sử dụng Bearer token
+			req.Header.Set("Authorization", "Bearer "+cfg.OpenAIAPIKey)
+		}
+	} else {
+		log.Printf("WARN: [%s] OPENAI_API_KEY không được cấu hình. Yêu cầu upstream sẽ không được xác thực.", requestID)
 	}
 
-	// Giữ lại: Log INFO quan trọng về việc gửi yêu cầu upstream
 	log.Printf("INFO: [%s] Gửi yêu cầu upstream (Stream=%t) đến %s...", requestID, isStreaming, maskURL(upstreamURL))
 
+	// Thực hiện yêu cầu HTTP đến upstream API
 	httpClient := &http.Client{
-		Transport: cfg.UpstreamTransport,
-		Timeout:   0, // Timeout is handled by Transport's DialContext and ResponseHeaderTimeout
+		Transport: cfg.UpstreamTransport, // Sử dụng transport đã được cấu hình (timeout, proxy, etc.)
+		Timeout:   0,                     // Timeout được quản lý bởi Transport
 	}
 	upstreamResp, err := httpClient.Do(req)
 	if err != nil {
-		// Giữ lại: Log lỗi quan trọng
 		log.Printf("ERROR: [%s] Yêu cầu upstream thất bại: %v", requestID, err)
 		if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
 			sendClaudeError(c, http.StatusGatewayTimeout, "api_error", fmt.Sprintf("Gateway Timeout khi kết nối upstream (%v).", cfg.ConnectTimeout))
@@ -177,19 +199,17 @@ func MessagesHandler(c *gin.Context) {
 		}
 		return
 	}
-	// Giữ lại: Log INFO quan trọng về trạng thái upstream
 	log.Printf("INFO: [%s] Nhận trạng thái upstream: %d (%s)", requestID, upstreamResp.StatusCode, http.StatusText(upstreamResp.StatusCode))
 
+	// Xử lý phản hồi lỗi từ upstream API
 	if upstreamResp.StatusCode != http.StatusOK {
 		errorBodyBytes, readErr := io.ReadAll(upstreamResp.Body)
 		if readErr != nil {
-			// Giữ lại: Log cảnh báo
 			log.Printf("WARN: [%s] Không thể đọc nội dung lỗi upstream (Status %d): %v", requestID, upstreamResp.StatusCode, readErr)
 		}
-		_ = upstreamResp.Body.Close()
+		_ = upstreamResp.Body.Close() // Luôn đóng body của phản hồi
 
 		errorBodyStr := string(errorBodyBytes)
-		// Giữ lại: Log lỗi quan trọng
 		log.Printf("ERROR: [%s] Upstream trả về lỗi %d. Chi tiết ngắn: %s", requestID, upstreamResp.StatusCode, truncateString(strings.TrimSpace(errorBodyStr), 100))
 
 		var errorType string
@@ -210,54 +230,47 @@ func MessagesHandler(c *gin.Context) {
 		return
 	}
 
+	// Xử lý phản hồi thành công từ upstream API
 	if isStreaming {
 		if cfg.UpstreamNativeClaudeFormat {
-			// Giữ lại: Log INFO quan trọng
 			log.Printf("INFO: [%s] Upstream Claude native stream nhận được. Bắt đầu proxy SSE (với hack usage).", requestID)
-			proxyClaudeNativeSSE(c, upstreamResp, requestID, &claudeReq) // SỬA Ở ĐÂY: Thêm &claudeReq
+			proxyClaudeNativeSSE(c, upstreamResp, requestID, &claudeReq)
 		} else {
-			// Giữ lại: Log INFO quan trọng
 			log.Printf("INFO: [%s] Upstream OpenAI stream nhận được. Bắt đầu chuyển đổi SSE.", requestID)
-			modelForConversion := claudeReq.Model
+			modelForConversion := claudeReq.Model // Model gốc từ yêu cầu client
 			if openAIReqForLogging != nil && openAIReqForLogging.Model != "" {
-				modelForConversion = openAIReqForLogging.Model
+				modelForConversion = openAIReqForLogging.Model // Model đã được chuyển đổi (nếu có)
 			}
 			streamOpenAIResponseToClaudeSSE(c, upstreamResp, requestID, modelForConversion, &claudeReq)
 		}
 	} else { // Non-streaming
-		// Giữ lại: Log INFO quan trọng
 		log.Printf("INFO: [%s] Phản hồi non-stream upstream nhận được. Đang xử lý.", requestID)
-		defer upstreamResp.Body.Close()
+		defer upstreamResp.Body.Close() // Đảm bảo body được đóng sau khi xử lý
 
 		respBodyBytes, errRead := io.ReadAll(upstreamResp.Body)
 		if errRead != nil {
-			// Giữ lại: Log lỗi quan trọng
 			log.Printf("ERROR: [%s] Không thể đọc nội dung phản hồi non-streaming upstream: %v", requestID, errRead)
 			sendClaudeError(c, http.StatusBadGateway, "api_error", "Không thể đọc phản hồi upstream.")
 			return
 		}
 
 		if cfg.UpstreamNativeClaudeFormat {
-			// Giữ lại: Log INFO
 			log.Printf("INFO: [%s] Upstream Claude native non-stream response nhận được. Chuyển tiếp trực tiếp.", requestID)
-			var tempClaudeResp map[string]interface{}
+			var tempClaudeResp map[string]interface{} // Kiểm tra xem có phải JSON hợp lệ không
 			if errJson := json.Unmarshal(respBodyBytes, &tempClaudeResp); errJson != nil {
-				// Giữ lại: Log lỗi quan trọng
 				log.Printf("ERROR: [%s] Upstream Claude native response không phải JSON hợp lệ: %v. Body: %s", requestID, errJson, string(respBodyBytes))
 				sendClaudeError(c, http.StatusBadGateway, "api_error", "API upstream (Claude native) trả về JSON không hợp lệ.")
 				return
 			}
 			clientContentType := upstreamResp.Header.Get("Content-Type")
 			if clientContentType == "" {
-				clientContentType = "application/json; charset=utf-8"
+				clientContentType = "application/json; charset=utf-8" // Mặc định nếu không có
 			}
-			c.Data(http.StatusOK, clientContentType, respBodyBytes)
+			c.Data(http.StatusOK, clientContentType, respBodyBytes) // Gửi dữ liệu thô về client
 		} else {
-			// Giữ lại: Log INFO
 			log.Printf("INFO: [%s] Phản hồi non-stream OpenAI upstream nhận được. Đang chuyển đổi.", requestID)
 			var openAIResp OpenAIResponse
 			if errJson := json.Unmarshal(respBodyBytes, &openAIResp); errJson != nil {
-				// Giữ lại: Log lỗi quan trọng
 				log.Printf("ERROR: [%s] Không thể giải mã JSON non-streaming OpenAI upstream: %v. Body: %s", requestID, errJson, string(respBodyBytes))
 				sendClaudeError(c, http.StatusBadGateway, "api_error", "API upstream (OpenAI) trả về JSON không hợp lệ.")
 				return
@@ -265,18 +278,17 @@ func MessagesHandler(c *gin.Context) {
 
 			claudeRespToClient, errConv := convertOpenAIResponseToClaude(&openAIResp, requestID)
 			if errConv != nil {
-				// Giữ lại: Log lỗi quan trọng
 				log.Printf("ERROR: [%s] Không thể chuyển đổi phản hồi non-streaming OpenAI: %v", requestID, errConv)
 				sendClaudeError(c, http.StatusInternalServerError, "internal_server_error", fmt.Sprintf("Lỗi xử lý phản hồi upstream: %v", errConv))
 				return
 			}
 			c.JSON(http.StatusOK, claudeRespToClient)
 		}
-		// Giữ lại: Log INFO hữu ích về thời gian xử lý
 		log.Printf("INFO: [%s] Xử lý thành công yêu cầu non-streaming trong %v", requestID, time.Since(startTime))
 	}
 }
 
+// sendClaudeError gửi phản hồi lỗi theo định dạng Claude về client.
 func sendClaudeError(c *gin.Context, statusCode int, errorType string, message string) {
 	errResp := ClaudeErrorResponse{
 		Type: "error",
@@ -285,14 +297,14 @@ func sendClaudeError(c *gin.Context, statusCode int, errorType string, message s
 			Message: message,
 		},
 	}
-	if statusCode < 400 || statusCode > 599 {
-		// Giữ lại: Log cảnh báo về mã trạng thái không hợp lệ
+	if statusCode < 400 || statusCode > 599 { // Đảm bảo mã trạng thái HTTP hợp lệ cho lỗi
 		log.Printf("WARN: Mã trạng thái không hợp lệ %d được cung cấp cho lỗi, mặc định thành 500.", statusCode)
 		statusCode = http.StatusInternalServerError
 	}
-	c.AbortWithStatusJSON(statusCode, errResp)
+	c.AbortWithStatusJSON(statusCode, errResp) // Gửi lỗi và dừng xử lý tiếp theo
 }
 
+// truncateString rút gọn chuỗi nếu nó dài hơn maxLength.
 func truncateString(s string, maxLength int) string {
 	if len(s) <= maxLength {
 		return s