Update main.go

main.go

@@ -5,19 +5,11 @@ import (
 	"bytes"
 	"encoding/json"
 	"io"
-	"log"
 	"net/http"
-	"time"
 
 	"github.com/gin-gonic/gin"
 )
 
-const (
-	statusURL  = "https://duckduckgo.com/duckchat/v1/status"
-	chatURL    = "https://duckduckgo.com/duckchat/v1/chat"
-	userAgent = "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:123.0) Gecko/20100101 Firefox/123.0"
-)
-
 type OpenAIRequest struct {
 	Model    string `json:"model"`
 	Messages []struct {
@@ -74,58 +66,77 @@ func chatWithDuckDuckGo(c *gin.Context, messages []struct {
 	Role    string `json:"role"`
 	Content string `json:"content"`
 }, stream bool) {
-	client := &http.Client{Timeout: 10 * time.Second}
+	userAgent := "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:123.0) Gecko/20100101 Firefox/123.0"
+	headers := map[string]string{
+		"User-Agent":      userAgent,
+		"Accept":          "text/event-stream",
+		"Accept-Language": "de,en-US;q=0.7,en;q=0.3",
+		"Accept-Encoding": "gzip, deflate, br",
+		"Referer":         "https://duckduckgo.com/",
+		"Content-Type":    "application/json",
+		"Origin":          "https://duckduckgo.com",
+		"Connection":      "keep-alive",
+		"Cookie":          "dcm=1",
+		"Sec-Fetch-Dest":  "empty",
+		"Sec-Fetch-Mode":  "cors",
+		"Sec-Fetch-Site":  "same-origin",
+		"Pragma":          "no-cache",
+		"TE":              "trailers",
+	}
+
+	statusURL := "https://duckduckgo.com/duckchat/v1/status"
+	chatURL := "https://duckduckgo.com/duckchat/v1/chat"
 
-	// Get vqd_4
+	// get vqd_4
 	req, err := http.NewRequest("GET", statusURL, nil)
 	if err != nil {
-		log.Println(err)
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create request"})
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
+
 	req.Header.Set("x-vqd-accept", "1")
-	setHeaders(req, userAgent)
+	for key, value := range headers {
+		req.Header.Set(key, value)
+	}
 
-	resp, err := client.Do(req)
+	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
-		log.Println(err)
-	c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get vqd_4"})
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
 	defer resp.Body.Close()
 
 	vqd4 := resp.Header.Get("x-vqd-4")
 
-	// Send chat request
 	payload := map[string]interface{}{
 		"model":    "gpt-3.5-turbo-0125",
 		"messages": messages,
 	}
+
 	payloadBytes, err := json.Marshal(payload)
 	if err != nil {
-		log.Println(err)
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to marshal payload"})
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
 
 	req, err = http.NewRequest("POST", chatURL, bytes.NewBuffer(payloadBytes))
 	if err != nil {
-		log.Println(err)
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create request"})
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
+
 	req.Header.Set("x-vqd-4", vqd4)
-	setHeaders(req, userAgent)
+	for key, value := range headers {
+		req.Header.Set(key, value)
+	}
 
-	resp, err = client.Do(req)
+	resp, err = http.DefaultClient.Do(req)
 	if err != nil {
-		log.Println(err)
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to send chat request"})
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
 	defer resp.Body.Close()
 
-	// Process response
 	reader := bufio.NewReader(resp.Body)
 	c.Header("Content-Type", "text/event-stream")
 	c.Header("Cache-Control", "no-cache")
@@ -135,7 +146,9 @@ func chatWithDuckDuckGo(c *gin.Context, messages []struct {
 	flusher, _ := c.Writer.(http.Flusher)
 
 	var response OpenAIResponse
+	var nonStreamResponse OpenAINonStreamResponse
 	response.Choices = make([]OpenAIChoice, 1)
+	nonStreamResponse.Choices = make([]OpenAINonStreamChoice, 1)
 
 	var responseContent string
 
@@ -153,12 +166,36 @@ func chatWithDuckDuckGo(c *gin.Context, messages []struct {
 			chunk := line[6:]
 
 			if bytes.HasPrefix(chunk, []byte("[DONE]")) {
-				response.Choices[0].Delta.Content = responseContent
-				response.Choices[0].Delta.Role = "assistant"
-				response.Choices[0].FinishReason = new(string)
-				*response.Choices[0].FinishReason = "stop"
-				c.JSON(http.StatusOK, response)
-				return
+				if !stream {
+					nonStreamResponse.Choices[0].Message.Content = responseContent
+					nonStreamResponse.Choices[0].Message.Role = "assistant"
+					nonStreamResponse.Choices[0].FinishReason = new(string)
+					*nonStreamResponse.Choices[0].FinishReason = "stop"
+					c.JSON(http.StatusOK, nonStreamResponse)
+					return
+				} else {
+					stopData := OpenAIResponse{
+						ID:      "chatcmpl-9HOzx2PhnYCLPxQ3Dpa2OKoqR2lgl",
+						Object:  "chat.completion",
+						Created: 1713934697,
+						Model:   "gpt-3.5-turbo-0125",
+						Choices: []OpenAIChoice{
+							{
+								Index:        0,
+								FinishReason: stringPtr("stop"),
+							},
+						},
+					}
+					stopDataBytes, _ := json.Marshal(stopData)
+					c.Data(http.StatusOK, "application/json", []byte("data: "))
+					c.Data(http.StatusOK, "application/json", stopDataBytes)
+					c.Data(http.StatusOK, "application/json", []byte("\n\n"))
+					flusher.Flush()
+
+					c.Data(http.StatusOK, "application/json", []byte("data: [DONE]\n\n"))
+					flusher.Flush()
+					return
+				}
 			}
 
 			var data DuckDuckGoResponse
@@ -174,6 +211,10 @@ func chatWithDuckDuckGo(c *gin.Context, messages []struct {
 			response.Object = "chat.completion"
 			response.Created = data.Created
 			response.Model = data.Model
+			nonStreamResponse.ID = data.ID
+			nonStreamResponse.Object = "chat.completion"
+			nonStreamResponse.Created = data.Created
+			nonStreamResponse.Model = data.Model
 			responseContent += data.Message
 
 			if stream {
@@ -195,21 +236,8 @@ func chatWithDuckDuckGo(c *gin.Context, messages []struct {
 	}
 }
 
-func setHeaders(req *http.Request, userAgent string) {
-	req.Header.Set("User-Agent", userAgent)
-	req.Header.Set("Accept", "text/event-stream")
-	req.Header.Set("Accept-Language", "de,en-US;q=0.7,en;q=0.3")
-	req.Header.Set("Accept-Encoding", "gzip, deflate, br")
-	req.Header.Set("Referer", "https://duckduckgo.com/")
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Origin", "https://duckduckgo.com")
-	req.Header.Set("Connection", "keep-alive")
-	req.Header.Set("Cookie", "dcm=1")
-	req.Header.Set("Sec-Fetch-Dest", "empty")
-	req.Header.Set("Sec-Fetch-Mode", "cors")
-	req.Header.Set("Sec-Fetch-Site", "same-origin")
-	req.Header.Set("Pragma", "no-cache")
-	req.Header.Set("TE", "trailers")
+func stringPtr(s string) *string {
+	return &s
 }
 
 func main() {
@@ -221,13 +249,13 @@ func main() {
 			"message": "Hello! Thank you for using FreeDuckDuckGo. Made by Vincent Yang. Repo: https://github.com/missuo/FreeDuckDuckGo",
 		})
 	})
-
+	
 	r.OPTIONS("/v1/chat/completions", func(c *gin.Context) {
-		c.Header("Access-Control-Allow-Origin", "*")
-		c.Header("Access-Control-Allow-Methods", "POST, OPTIONS")
-		c.Header("Access-Control-Allow-Headers", "Content-Type, Accept, Origin, X-Requested-With")
-		c.Status(http.StatusOK)
+		c.JSON(http.StatusOK, gin.H{
+			"message": "ok",
+		})
 	})
+	
 
 	r.POST("/v1/chat/completions", func(c *gin.Context) {
 		var req OpenAIRequest