Update main.go

main.go

@@ -5,11 +5,19 @@ 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 {
@@ -66,77 +74,58 @@ func chatWithDuckDuckGo(c *gin.Context, messages []struct {
 	Role    string `json:"role"`
 	Content string `json:"content"`
 }, stream bool) {
-	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"
+	client := &http.Client{Timeout: 10 * time.Second}
 
-	// get vqd_4
+	// Get vqd_4
 	req, err := http.NewRequest("GET", statusURL, nil)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		log.Println(err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create request"})
 		return
 	}
-
 	req.Header.Set("x-vqd-accept", "1")
-	for key, value := range headers {
-		req.Header.Set(key, value)
-	}
+	setHeaders(req, userAgent)
 
-	resp, err := http.DefaultClient.Do(req)
+	resp, err := client.Do(req)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		log.Println(err)
+	c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get vqd_4"})
 		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 {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		log.Println(err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to marshal payload"})
 		return
 	}
 
 	req, err = http.NewRequest("POST", chatURL, bytes.NewBuffer(payloadBytes))
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		log.Println(err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create request"})
 		return
 	}
-
 	req.Header.Set("x-vqd-4", vqd4)
-	for key, value := range headers {
-		req.Header.Set(key, value)
-	}
+	setHeaders(req, userAgent)
 
-	resp, err = http.DefaultClient.Do(req)
+	resp, err = client.Do(req)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		log.Println(err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to send chat request"})
 		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")
@@ -146,9 +135,7 @@ 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
 
@@ -166,36 +153,12 @@ func chatWithDuckDuckGo(c *gin.Context, messages []struct {
 			chunk := line[6:]
 
 			if bytes.HasPrefix(chunk, []byte("[DONE]")) {
-				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
-				}
+				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
 			}
 
 			var data DuckDuckGoResponse
@@ -211,10 +174,6 @@ 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 {
@@ -236,8 +195,21 @@ func chatWithDuckDuckGo(c *gin.Context, messages []struct {
 	}
 }
 
-func stringPtr(s string) *string {
-	return &s
+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 main() {
@@ -250,6 +222,13 @@ func main() {
 		})
 	})
 
+	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)
+	})
+
 	r.POST("/v1/chat/completions", func(c *gin.Context) {
 		var req OpenAIRequest
 		if err := c.ShouldBindJSON(&req); err != nil {
@@ -282,4 +261,4 @@ func main() {
 	})
 
 	r.Run(":3456")
-}
+}