Upload 45 files

.gitignore

@@ -0,0 +1,15 @@
+tools/authenticator/100-ACCOUNTS_COMPILED.txt
+tools/authenticator/accounts.txt
+tools/authenticator/proxies.txt
+tools/authenticator/authenticated_accounts.txt
+tools/authenticator/access_tokens.txt
+*.txt
+aurora
+chatgpttoapi
+tools/authenticator/.proxies.txt.swp
+.env
+*.har
+.idea/
+/logs/
+/target/
+/bin/

Dockerfile

@@ -0,0 +1,32 @@
+# 使用 Go 1.21 官方镜像作为构建环境
+FROM golang:1.21 AS builder
+
+# 禁用 CGO
+ENV CGO_ENABLED=0
+
+# 设置工作目录
+WORKDIR /app
+
+# 复制 go.mod 和 go.sum 并下载依赖
+COPY go.mod go.sum ./
+RUN go mod download
+
+# 复制源代码并构建应用
+COPY . .
+RUN go build -ldflags "-s -w" -o /app/duck2api .
+
+# 使用 Alpine Linux 作为最终镜像
+FROM alpine:latest
+
+# 设置工作目录
+WORKDIR /app
+RUN apk add --no-cache tzdata
+
+# 从构建阶段复制编译好的应用和资源
+COPY --from=builder /app/duck2api /app/duck2api
+COPY harPool /app/harPool
+
+# 暴露端口
+EXPOSE 8080
+
+CMD ["/app/duck2api"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 aurora-develop
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Procfile

@@ -0,0 +1 @@
+web: aurora

VERSION

@@ -0,0 +1 @@
+2.0.0

api/router.go

@@ -0,0 +1,18 @@
+package api
+
+import (
+	"aurora/initialize"
+	"github.com/gin-gonic/gin"
+	"net/http"
+)
+
+var router *gin.Engine
+
+func init() {
+	// 初始化gin
+	router = initialize.RegisterRouter()
+}
+
+func Listen(w http.ResponseWriter, r *http.Request) {
+	router.ServeHTTP(w, r)
+}

build.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+
+export GOPROXY=https://goproxy.io
+
+go get
+
+export CGO_ENABLED=0
+PKG=aurora
+
+targets=(
+    "windows/amd64"
+    "linux/amd64"
+    "darwin/amd64"
+    "windows/386"
+    "linux/386"
+    "darwin/386"
+    "linux/arm"
+    "linux/arm64"
+    "linux/s390x"    
+)
+
+upxPath=$(command -v upx)
+
+for target in "${targets[@]}"; do
+    GOOS=${target%/*}
+    GOARCH=${target#*/}
+    outputDir="bin/${GOOS}_${GOARCH}"
+    outputFile="${outputDir}/${PKG}"
+    archiveName="${PKG}-${GOOS}-${GOARCH}.tar.gz"
+    mkdir -p $(dirname ${outputFile})
+    GOOS=$GOOS GOARCH=$GOARCH go build -ldflags="-s -w -extldflags '-static'" -o ${outputFile} *.go
+    if [ -n "$upxPath" ]; then
+        $upxPath -9 ${outputFile}
+    fi
+    # Archive the binary
+    if [ "$GOOS" = "windows" ]; then
+        zip -j "${outputDir}/${PKG}-${GOOS}-${GOARCH}.zip" "${outputFile}"
+    else
+        tar -C "${outputDir}" -czf "${outputDir}/${archiveName}" "${PKG}"
+    fi
+done

conversion/requests/chatgpt/convert.go

@@ -0,0 +1,66 @@
+package chatgpt
+
+import (
+	"fmt"
+	"strings"
+
+	"aurora/internal/tokens"
+	chatgpt_types "aurora/typings/chatgpt"
+	official_types "aurora/typings/official"
+
+	arkose "github.com/xqdoo00o/funcaptcha"
+)
+
+func ConvertAPIRequest(api_request official_types.APIRequest, secret *tokens.Secret, requireArk bool, proxy string) chatgpt_types.ChatGPTRequest {
+	chatgpt_request := chatgpt_types.NewChatGPTRequest()
+	var api_version int
+	if secret.PUID == "" {
+		api_request.Model = "gpt-3.5"
+	}
+	if strings.HasPrefix(api_request.Model, "gpt-3.5") {
+		api_version = 3
+		chatgpt_request.Model = "text-davinci-002-render-sha"
+	} else if strings.HasPrefix(api_request.Model, "gpt-4") {
+		api_version = 4
+		chatgpt_request.Model = api_request.Model
+		// Cover some models like gpt-4-32k
+		if len(api_request.Model) >= 7 && api_request.Model[6] >= 48 && api_request.Model[6] <= 57 {
+			chatgpt_request.Model = "gpt-4"
+		}
+	}
+	if requireArk {
+		token, err := arkose.GetOpenAIToken(api_version, secret.PUID, "", proxy)
+		if err == nil {
+			chatgpt_request.ArkoseToken = token
+		} else {
+			fmt.Println("Error getting Arkose token: ", err)
+		}
+	}
+
+	if api_request.PluginIDs != nil {
+		chatgpt_request.PluginIDs = api_request.PluginIDs
+		chatgpt_request.Model = "gpt-4-plugins"
+	}
+	for _, api_message := range api_request.Messages {
+		if api_message.Role == "system" {
+			api_message.Role = "critic"
+		}
+		chatgpt_request.AddMessage(api_message.Role, api_message.Content)
+	}
+	return chatgpt_request
+}
+
+func RenewTokenForRequest(request *chatgpt_types.ChatGPTRequest, puid string, proxy string) {
+	var api_version int
+	if strings.HasPrefix(request.Model, "gpt-4") {
+		api_version = 4
+	} else {
+		api_version = 3
+	}
+	token, err := arkose.GetOpenAIToken(api_version, puid, "", proxy)
+	if err == nil {
+		request.ArkoseToken = token
+	} else {
+		fmt.Println("Error getting Arkose token: ", err)
+	}
+}

conversion/response/chatgpt/convert.go

@@ -0,0 +1,20 @@
+package chatgpt
+
+import (
+	"strings"
+
+	"aurora/typings"
+	chatgpt_types "aurora/typings/chatgpt"
+	official_types "aurora/typings/official"
+)
+
+func ConvertToString(chatgpt_response *chatgpt_types.ChatGPTResponse, previous_text *typings.StringStruct, role bool) string {
+	translated_response := official_types.NewChatCompletionChunk(strings.Replace(chatgpt_response.Message.Content.Parts[0].(string), previous_text.Text, "", 1))
+	if role {
+		translated_response.Choices[0].Delta.Role = chatgpt_response.Message.Author.Role
+	} else if translated_response.Choices[0].Delta.Content == "" || (strings.HasPrefix(chatgpt_response.Message.Metadata.ModelSlug, "gpt-4") && translated_response.Choices[0].Delta.Content == "【") {
+		return translated_response.Choices[0].Delta.Content
+	}
+	previous_text.Text = chatgpt_response.Message.Content.Parts[0].(string)
+	return "data: " + translated_response.String() + "\n\n"
+}

docker-compose.yml

@@ -0,0 +1,9 @@
+version: '3'
+
+services:
+  app:
+    image: ghcr.io/aurora-develop/aurora:latest
+    container_name: aurora
+    restart: unless-stopped
+    ports:
+      - '8080:8080'

duckgo/convert.go

@@ -0,0 +1,30 @@
+package duckgo
+
+import (
+	officialtypes "aurora/typings/official"
+	"strings"
+)
+
+func ConvertAPIRequest(api_request officialtypes.APIRequest) ApiRequest {
+	duckgo_request := NewApiRequest(api_request.Model)
+	if strings.HasPrefix(duckgo_request.Model, "gpt-3.5") {
+		duckgo_request.Model = GPT3
+	}
+	if strings.HasPrefix(duckgo_request.Model, "claude") {
+		duckgo_request.Model = Claude
+	}
+	content := ""
+	for _, apiMessage := range api_request.Messages {
+		if apiMessage.Role == "user" {
+			content += "user:" + apiMessage.Content + "\r\n"
+		}
+		if apiMessage.Role == "system" {
+			content += "system:" + apiMessage.Content + "\r\n"
+		}
+		if apiMessage.Role == "assistant" {
+			content += "assistant:" + apiMessage.Content + "\r\n"
+		}
+	}
+	duckgo_request.AddMessage("user", content)
+	return duckgo_request
+}

duckgo/request.go

@@ -0,0 +1,184 @@
+package duckgo
+
+import (
+	"aurora/httpclient"
+	officialtypes "aurora/typings/official"
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"errors"
+	"github.com/gin-gonic/gin"
+	"io"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+)
+
+type ApiRequest struct {
+	Model    string `json:"model"`
+	Messages []struct {
+		Role    string `json:"role"`
+		Content string `json:"content"`
+	} `json:"messages"`
+}
+
+func (a *ApiRequest) AddMessage(role string, content string) {
+	a.Messages = append(a.Messages, struct {
+		Role    string `json:"role"`
+		Content string `json:"content"`
+	}{
+		Role:    role,
+		Content: content,
+	})
+}
+
+func NewApiRequest(model string) ApiRequest {
+	return ApiRequest{
+		Model: model,
+	}
+}
+
+func InitXVQD(client httpclient.AuroraHttpClient, proxyUrl string) (string, error) {
+	if Token == nil {
+		Token = &XqdgToken{
+			Token: "",
+			M:     sync.Mutex{},
+		}
+	}
+	Token.M.Lock()
+	defer Token.M.Unlock()
+	if Token.Token == "" || Token.ExpireAt.Before(time.Now()) {
+		status, err := postStatus(client, proxyUrl)
+		if err != nil {
+			return "", err
+		}
+		defer status.Body.Close()
+		token := status.Header.Get("x-vqd-4")
+		if token == "" {
+			return "", errors.New("no x-vqd-4 token")
+		}
+		Token.Token = token
+		Token.ExpireAt = time.Now().Add(time.Minute * 5)
+	}
+
+	return Token.Token, nil
+}
+
+func postStatus(client httpclient.AuroraHttpClient, proxyUrl string) (*http.Response, error) {
+	if proxyUrl != "" {
+		client.SetProxy(proxyUrl)
+	}
+	header := createHeader()
+	header.Set("accept", "*/*")
+	header.Set("x-vqd-accept", "1")
+	response, err := client.Request(httpclient.GET, "https://duckduckgo.com/duckchat/v1/status", header, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return response, nil
+}
+
+func POSTconversation(client httpclient.AuroraHttpClient, request ApiRequest, token string, proxyUrl string) (*http.Response, error) {
+	if proxyUrl != "" {
+		client.SetProxy(proxyUrl)
+	}
+	body_json, err := json.Marshal(request)
+	if err != nil {
+		return &http.Response{}, err
+	}
+	header := createHeader()
+	header.Set("accept", "text/event-stream")
+	header.Set("x-vqd-4", token)
+	response, err := client.Request(httpclient.POST, "https://duckduckgo.com/duckchat/v1/chat", header, nil, bytes.NewBuffer(body_json))
+	if err != nil {
+		return nil, err
+	}
+	return response, nil
+}
+
+func Handle_request_error(c *gin.Context, response *http.Response) bool {
+	if response.StatusCode == 400 {
+		c.JSON(400, gin.H{"error": gin.H{
+			"message": "Request must be proper JSON",
+			"type":    "invalid_request_error",
+			"param":   nil,
+			"code":    response.Status,
+		}})
+		return true
+	}
+	return false
+}
+
+func createHeader() httpclient.AuroraHeaders {
+	header := make(httpclient.AuroraHeaders)
+	header.Set("accept-language", "zh-CN,zh;q=0.9")
+	header.Set("content-type", "application/json")
+	header.Set("origin", "https://duckduckgo.com")
+	header.Set("referer", "https://duckduckgo.com/")
+	header.Set("sec-ch-ua", `"Chromium";v="120", "Google Chrome";v="120", "Not-A.Brand";v="99"`)
+	header.Set("sec-ch-ua-mobile", "?0")
+	header.Set("sec-ch-ua-platform", `"Windows"`)
+	header.Set("user-agent", UA)
+	return header
+}
+
+func Handler(c *gin.Context, response *http.Response, stream bool) string {
+	reader := bufio.NewReader(response.Body)
+	if stream {
+		// Response content type is text/event-stream
+		c.Header("Content-Type", "text/event-stream")
+	} else {
+		// Response content type is application/json
+		c.Header("Content-Type", "application/json")
+	}
+	var originalResponse ApiResponse
+	var previousText = ""
+	for {
+		line, err := reader.ReadString('\n')
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return ""
+		}
+		if len(line) < 6 {
+			continue
+		}
+		line = line[6:]
+		if !strings.HasPrefix(line, "[DONE]") {
+			err = json.Unmarshal([]byte(line), &originalResponse)
+			if err != nil {
+				continue
+			}
+			if originalResponse.Action != "success" {
+				c.JSON(500, gin.H{"error": "Error"})
+				return ""
+			}
+			responseString := ""
+			if originalResponse.Message != "" {
+				previousText += originalResponse.Message
+				translatedResponse := officialtypes.NewChatCompletionChunkWithModel(originalResponse.Message, originalResponse.Model)
+				responseString = "data: " + translatedResponse.String() + "\n\n"
+			}
+
+			if responseString == "" {
+				continue
+			}
+
+			if stream {
+				_, err = c.Writer.WriteString(responseString)
+				if err != nil {
+					return ""
+				}
+				c.Writer.Flush()
+			}
+		} else {
+			if stream {
+				final_line := officialtypes.StopChunkWithModel("stop", originalResponse.Model)
+				c.Writer.WriteString("data: " + final_line.String() + "\n\n")
+			}
+		}
+	}
+	return previousText
+}

duckgo/response.go

@@ -0,0 +1,9 @@
+package duckgo
+
+type ApiResponse struct {
+	Message string `json:"message"`
+	Created int    `json:"created"`
+	Id      string `json:"id"`
+	Action  string `json:"action"`
+	Model   string `json:"model"`
+}

duckgo/var.go

@@ -0,0 +1,22 @@
+package duckgo
+
+import (
+	"sync"
+	"time"
+)
+
+const (
+	Claude = "claude-instant-1.2"
+	GPT3   = "gpt-3.5-turbo-0125"
+	UA     = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+)
+
+var (
+	Token *XqdgToken
+)
+
+type XqdgToken struct {
+	Token    string     `json:"token"`
+	M        sync.Mutex `json:"-"`
+	ExpireAt time.Time  `json:"expire"`
+}

env.template

@@ -0,0 +1,8 @@
+SERVER_HOST=0.0.0.0
+SERVER_PORT=8080
+FREE_ACCOUNTS=true
+FREE_ACCOUNTS_NUM=1024
+Authorization=
+TLS_CERT=
+TLS_KEY=
+PROXY_URL=

go.mod

@@ -0,0 +1,56 @@
+module aurora
+
+go 1.21
+
+require (
+	github.com/EDDYCJY/fake-useragent v0.2.0
+	github.com/acheong08/endless v0.0.0-20230615162514-90545c7793fd
+	github.com/bogdanfinn/fhttp v0.5.27
+	github.com/bogdanfinn/tls-client v1.7.2
+	github.com/gin-gonic/gin v1.9.1
+	github.com/go-resty/resty/v2 v2.12.0
+	github.com/google/uuid v1.6.0
+	github.com/gorilla/websocket v1.5.1
+	github.com/joho/godotenv v1.5.1
+	github.com/pkoukk/tiktoken-go v0.1.6
+	github.com/xqdoo00o/funcaptcha v0.0.0-20240403090732-1b604d808f6c
+)
+
+require (
+	github.com/PuerkitoBio/goquery v1.9.1 // indirect
+	github.com/andybalholm/brotli v1.0.5 // indirect
+	github.com/andybalholm/cascadia v1.3.2 // indirect
+	github.com/bogdanfinn/utls v1.6.1 // indirect
+	github.com/bytedance/sonic v1.10.1 // indirect
+	github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d // indirect
+	github.com/chenzhuoyu/iasm v0.9.0 // indirect
+	github.com/cloudflare/circl v1.3.6 // indirect
+	github.com/dlclark/regexp2 v1.10.0 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.15.4 // indirect
+	github.com/goccy/go-json v0.10.2 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/compress v1.17.0 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.5 // indirect
+	github.com/kr/text v0.2.0 // indirect
+	github.com/leodido/go-urn v1.2.4 // indirect
+	github.com/mattn/go-isatty v0.0.19 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/pelletier/go-toml/v2 v2.1.0 // indirect
+	github.com/quic-go/quic-go v0.37.4 // indirect
+	github.com/rogpeppe/go-internal v1.12.0 // indirect
+	github.com/tam7t/hpkp v0.0.0-20160821193359-2b70b4024ed5 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.2.11 // indirect
+	golang.org/x/arch v0.5.0 // indirect
+	golang.org/x/crypto v0.21.0 // indirect
+	golang.org/x/net v0.22.0 // indirect
+	golang.org/x/sys v0.18.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
+	google.golang.org/protobuf v1.31.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

go.sum

@@ -0,0 +1,193 @@
+github.com/EDDYCJY/fake-useragent v0.2.0 h1:Jcnkk2bgXmDpX0z+ELlUErTkoLb/mxFBNd2YdcpvJBs=
+github.com/EDDYCJY/fake-useragent v0.2.0/go.mod h1:5wn3zzlDxhKW6NYknushqinPcAqZcAPHy8lLczCdJdc=
+github.com/PuerkitoBio/goquery v1.9.1 h1:mTL6XjbJTZdpfL+Gwl5U2h1l9yEkJjhmlTeV9VPW7UI=
+github.com/PuerkitoBio/goquery v1.9.1/go.mod h1:cW1n6TmIMDoORQU5IU/P1T3tGFunOeXEpGP2WHRwkbY=
+github.com/acheong08/endless v0.0.0-20230615162514-90545c7793fd h1:oIpfrRhD7Jus41dotbK+SQjWSFRnf1cLZUYCZpF/o/4=
+github.com/acheong08/endless v0.0.0-20230615162514-90545c7793fd/go.mod h1:0yO7neMeJLvKk/B/fq5votDY8rByrOPDubpvU+6saKo=
+github.com/andybalholm/brotli v1.0.5 h1:8uQZIdzKmjc/iuPu7O2ioW48L81FgatrcpfFmiq/cCs=
+github.com/andybalholm/brotli v1.0.5/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
+github.com/andybalholm/cascadia v1.3.2 h1:3Xi6Dw5lHF15JtdcmAHD3i1+T8plmv7BQ/nsViSLyss=
+github.com/andybalholm/cascadia v1.3.2/go.mod h1:7gtRlve5FxPPgIgX36uWBX58OdBsSS6lUvCFb+h7KvU=
+github.com/bogdanfinn/fhttp v0.5.27 h1:+glR3k8v5nxfUSk7+J3M246zEQ2yadhS0vLq1utK71A=
+github.com/bogdanfinn/fhttp v0.5.27/go.mod h1:oJiYPG3jQTKzk/VFmogH8jxjH5yiv2rrOH48Xso2lrE=
+github.com/bogdanfinn/tls-client v1.7.2 h1:vpL5qBYUfT9ueygEf1yLfymrXyUEZQatL25amfqGV8M=
+github.com/bogdanfinn/tls-client v1.7.2/go.mod h1:pOGa2euqTbEkGNqE5idx5jKKfs9ytlyn3fwEw8RSP+g=
+github.com/bogdanfinn/utls v1.6.1 h1:dKDYAcXEyFFJ3GaWaN89DEyjyRraD1qb4osdEK89ass=
+github.com/bogdanfinn/utls v1.6.1/go.mod h1:VXIbRZaiY/wHZc6Hu+DZ4O2CgTzjhjCg/Ou3V4r/39Y=
+github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM=
+github.com/bytedance/sonic v1.10.0-rc/go.mod h1:ElCzW+ufi8qKqNW0FY314xriJhyJhuoJ3gFZdAHF7NM=
+github.com/bytedance/sonic v1.10.1 h1:7a1wuFXL1cMy7a3f7/VFcEtriuXQnUBhtoVfOZiaysc=
+github.com/bytedance/sonic v1.10.1/go.mod h1:iZcSUejdk5aukTND/Eu/ivjQuEL0Cu9/rf50Hi0u/g4=
+github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
+github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
+github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d h1:77cEq6EriyTZ0g/qfRdp61a3Uu/AWrgIq2s0ClJV1g0=
+github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d/go.mod h1:8EPpVsBuRksnlj1mLy4AWzRNQYxauNi62uWcE3to6eA=
+github.com/chenzhuoyu/iasm v0.9.0 h1:9fhXjVzq5hUy2gkhhgHl95zG2cEAhw9OSGs8toWWAwo=
+github.com/chenzhuoyu/iasm v0.9.0/go.mod h1:Xjy2NpN3h7aUqeqM+woSuuvxmIe6+DDsiNLIrkAmYog=
+github.com/cloudflare/circl v1.3.6 h1:/xbKIqSHbZXHwkhbrhrt2YOHIwYJlXH94E3tI/gDlUg=
+github.com/cloudflare/circl v1.3.6/go.mod h1:5XYMA4rFBvNIrhs50XuiBJ15vF2pZn4nnUKZrLbUZFA=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dlclark/regexp2 v1.10.0 h1:+/GIL799phkJqYW+3YbOd8LCcbHzT0Pbo8zl70MHsq0=
+github.com/dlclark/regexp2 v1.10.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU=
+github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
+github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SUcPTeU=
+github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ=
+github.com/go-logr/logr v1.2.4/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
+github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
+github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
+github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
+github.com/go-playground/validator/v10 v10.15.4 h1:zMXza4EpOdooxPel5xDqXEdXG5r+WggpvnAKMsalBjs=
+github.com/go-playground/validator/v10 v10.15.4/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
+github.com/go-resty/resty/v2 v2.12.0 h1:rsVL8P90LFvkUYq/V5BTVe203WfRIU4gvcf+yfzJzGA=
+github.com/go-resty/resty/v2 v2.12.0/go.mod h1:o0yGPrkS3lOe1+eFajk6kBW8ScXzwU3hD69/gt2yB/0=
+github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI=
+github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls=
+github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
+github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38 h1:yAJXTCF9TqKcTiHJAE8dj7HMvPfh66eeA2JYW7eFpSE=
+github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/websocket v1.5.1 h1:gmztn0JnHVt9JZquRuzLw3g4wouNVzKL15iLr/zn/QY=
+github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY=
+github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
+github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/klauspost/compress v1.17.0 h1:Rnbp4K9EjcDuVuHtd0dgA4qNuv9yKDYKK1ulpJwgrqM=
+github.com/klauspost/compress v1.17.0/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.2.5 h1:0E5MSMDEoAulmXNFquVs//DdoomxaoTY1kUhbc/qbZg=
+github.com/klauspost/cpuid/v2 v2.2.5/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
+github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
+github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
+github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/onsi/ginkgo/v2 v2.9.5 h1:+6Hr4uxzP4XIUyAkg61dWBw8lb/gc4/X5luuxN/EC+Q=
+github.com/onsi/ginkgo/v2 v2.9.5/go.mod h1:tvAoo1QUJwNEU2ITftXTpR7R1RbCzoZUOs3RonqW57k=
+github.com/onsi/gomega v1.27.6 h1:ENqfyGeS5AX/rlXDd/ETokDz93u0YufY1Pgxuy/PvWE=
+github.com/onsi/gomega v1.27.6/go.mod h1:PIQNjfQwkP3aQAH7lf7j87O/5FiNr+ZR8+ipb+qQlhg=
+github.com/pelletier/go-toml/v2 v2.1.0 h1:FnwAJ4oYMvbT/34k9zzHuZNrhlz48GB3/s6at6/MHO4=
+github.com/pelletier/go-toml/v2 v2.1.0/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc=
+github.com/pkoukk/tiktoken-go v0.1.6 h1:JF0TlJzhTbrI30wCvFuiw6FzP2+/bR+FIxUdgEAcUsw=
+github.com/pkoukk/tiktoken-go v0.1.6/go.mod h1:9NiV+i9mJKGj1rYOT+njbv+ZwA/zJxYdewGl6qVatpg=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/quic-go/quic-go v0.37.4 h1:ke8B73yMCWGq9MfrCCAw0Uzdm7GaViC3i39dsIdDlH4=
+github.com/quic-go/quic-go v0.37.4/go.mod h1:YsbH1r4mSHPJcLF4k4zruUkLBqctEMBDR6VPvcYjIsU=
+github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
+github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/tam7t/hpkp v0.0.0-20160821193359-2b70b4024ed5 h1:YqAladjX7xpA6BM04leXMWAEjS0mTZ5kUU9KRBriQJc=
+github.com/tam7t/hpkp v0.0.0-20160821193359-2b70b4024ed5/go.mod h1:2JjD2zLQYH5HO74y5+aE3remJQvl6q4Sn6aWA2wD1Ng=
+github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
+github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
+github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU=
+github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+github.com/xqdoo00o/funcaptcha v0.0.0-20240403090732-1b604d808f6c h1:nj17XsSTwprsZUDXLldOUZmqz7VlHsLCeXXFOE6Q+Mk=
+github.com/xqdoo00o/funcaptcha v0.0.0-20240403090732-1b604d808f6c/go.mod h1:7aCyoW5MHDUsoooMVLqKe0F7W9HMPUvDG3bXqw++8XA=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/arch v0.5.0 h1:jpGode6huXQxcskEIpOCvrU+tzo81b6+oFLUYXWtH/Y=
+golang.org/x/arch v0.5.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
+golang.org/x/crypto v0.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA=
+golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
+golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
+golang.org/x/net v0.22.0 h1:9sGLhx7iRIHEiX0oAJ3MRZMUCElJgy7Br1nO+AMN3Tc=
+golang.org/x/net v0.22.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4=
+golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
+golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
+golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
+golang.org/x/term v0.18.0/go.mod h1:ILwASektA3OnRv7amZ1xhE/KTR+u50pbXfZ03+6Nx58=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
+golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+golang.org/x/tools v0.9.1 h1:8WMNJAz3zrtPmnYC7ISf5dEn3MT0gY7jBJfw27yrrLo=
+golang.org/x/tools v0.9.1/go.mod h1:owI94Op576fPu3cIGQeHs3joujW/2Oc6MtlxbF5dfNc=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
+google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=
+rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=

httpclient/Iaurorahttpclient.go

@@ -0,0 +1,28 @@
+package httpclient
+
+import (
+	"io"
+	"net/http"
+)
+
+type AuroraHttpClient interface {
+	Request(method HttpMethod, url string, headers AuroraHeaders, cookies []*http.Cookie, body io.Reader) (*http.Response, error)
+	SetProxy(url string) error
+}
+
+type HttpMethod string
+
+const (
+	GET     HttpMethod = "GET"
+	POST    HttpMethod = "POST"
+	PUT     HttpMethod = "PUT"
+	HEAD    HttpMethod = "HEAD"
+	DELETE  HttpMethod = "DELETE"
+	OPTIONS HttpMethod = "OPTIONS"
+)
+
+type AuroraHeaders map[string]string
+
+func (a AuroraHeaders) Set(key, value string) {
+	a[key] = value
+}

httpclient/bogdanfinn/tls_client.go

@@ -0,0 +1,101 @@
+package bogdanfinn
+
+import (
+	"aurora/httpclient"
+	"io"
+	"net/http"
+
+	fhttp "github.com/bogdanfinn/fhttp"
+	tls_client "github.com/bogdanfinn/tls-client"
+	"github.com/bogdanfinn/tls-client/profiles"
+)
+
+type TlsClient struct {
+	Client    tls_client.HttpClient
+	ReqBefore handler
+}
+
+type handler func(r *fhttp.Request) error
+
+func NewStdClient() *TlsClient {
+	client, _ := tls_client.NewHttpClient(tls_client.NewNoopLogger(), []tls_client.HttpClientOption{
+		tls_client.WithCookieJar(tls_client.NewCookieJar()),
+		tls_client.WithTimeoutSeconds(600),
+		tls_client.WithClientProfile(profiles.Safari_15_6_1),
+	}...)
+
+	stdClient := &TlsClient{Client: client}
+	return stdClient
+}
+
+func convertResponse(resp *fhttp.Response) *http.Response {
+	response := &http.Response{
+		Status:           resp.Status,
+		StatusCode:       resp.StatusCode,
+		Proto:            resp.Proto,
+		ProtoMajor:       resp.ProtoMajor,
+		ProtoMinor:       resp.ProtoMinor,
+		Header:           http.Header(resp.Header),
+		Body:             resp.Body,
+		ContentLength:    resp.ContentLength,
+		TransferEncoding: resp.TransferEncoding,
+		Close:            resp.Close,
+		Uncompressed:     resp.Uncompressed,
+		Trailer:          http.Header(resp.Trailer),
+	}
+	return response
+}
+
+func (t *TlsClient) handleHeaders(req *fhttp.Request, headers httpclient.AuroraHeaders) {
+	if headers == nil {
+		return
+	}
+	for k, v := range headers {
+		req.Header.Set(k, v)
+	}
+}
+
+func (t *TlsClient) handleCookies(req *fhttp.Request, cookies []*http.Cookie) {
+	if cookies == nil {
+		return
+	}
+	for _, c := range cookies {
+		req.AddCookie(&fhttp.Cookie{
+			Name:       c.Name,
+			Value:      c.Value,
+			Path:       c.Path,
+			Domain:     c.Domain,
+			Expires:    c.Expires,
+			RawExpires: c.RawExpires,
+			MaxAge:     c.MaxAge,
+			Secure:     c.Secure,
+			HttpOnly:   c.HttpOnly,
+			SameSite:   fhttp.SameSite(c.SameSite),
+			Raw:        c.Raw,
+			Unparsed:   c.Unparsed,
+		})
+	}
+}
+
+func (t *TlsClient) Request(method httpclient.HttpMethod, url string, headers httpclient.AuroraHeaders, cookies []*http.Cookie, body io.Reader) (*http.Response, error) {
+	req, err := fhttp.NewRequest(string(method), url, body)
+	if err != nil {
+		return nil, err
+	}
+	t.handleHeaders(req, headers)
+	t.handleCookies(req, cookies)
+	if t.ReqBefore != nil {
+		if err := t.ReqBefore(req); err != nil {
+			return nil, err
+		}
+	}
+	do, err := t.Client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	return convertResponse(do), nil
+}
+
+func (t *TlsClient) SetProxy(url string) error {
+	return t.Client.SetProxy(url)
+}

httpclient/bogdanfinn/tls_client_test.go

@@ -0,0 +1,111 @@
+package bogdanfinn
+
+import (
+	"aurora/httpclient"
+	chatgpt_types "aurora/typings/chatgpt"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/joho/godotenv"
+)
+
+var BaseURL string
+
+func init() {
+	_ = godotenv.Load(".env")
+	BaseURL = os.Getenv("BASE_URL")
+	if BaseURL == "" {
+		BaseURL = "https://chat.openai.com/backend-anon"
+	}
+}
+func TestTlsClient_Request(t *testing.T) {
+	client := NewStdClient()
+	userAgent := "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36"
+	proxy := "http://127.0.0.1:7990"
+	client.SetProxy(proxy)
+
+	apiUrl := BaseURL + "/sentinel/chat-requirements"
+	payload := strings.NewReader(`{"conversation_mode_kind":"primary_assistant"}`)
+	header := make(httpclient.AuroraHeaders)
+	header.Set("Content-Type", "application/json")
+	header.Set("User-Agent", userAgent)
+	header.Set("Accept", "*/*")
+	header.Set("oai-language", "en-US")
+	header.Set("origin", "https://chat.openai.com")
+	header.Set("referer", "https://chat.openai.com/")
+	header.Set("oai-device-id", "c83b24f0-5a9e-4c43-8915-3f67d4332609")
+	response, err := client.Request(http.MethodPost, apiUrl, header, nil, payload)
+	if err != nil {
+		return
+	}
+	defer response.Body.Close()
+	fmt.Println(response.StatusCode)
+	if response.StatusCode != 200 {
+		fmt.Println("Error: ", response.StatusCode)
+	}
+	var result chatgpt_types.RequirementsResponse
+	if err := json.NewDecoder(response.Body).Decode(&result); err != nil {
+		return
+	}
+	fmt.Println(result.Token)
+}
+
+func TestChatGPTModel(t *testing.T) {
+	client := NewStdClient()
+	userAgent := "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36"
+	proxy := "http://127.0.0.1:7990"
+	client.SetProxy(proxy)
+	apiUrl := "https://chat.openai.com/backend-anon/models"
+
+	header := make(httpclient.AuroraHeaders)
+	header.Set("Content-Type", "application/json")
+	header.Set("User-Agent", userAgent)
+	header.Set("Accept", "*/*")
+	header.Set("oai-language", "en-US")
+	header.Set("origin", "https://chat.openai.com")
+	header.Set("referer", "https://chat.openai.com/")
+	header.Set("oai-device-id", "c83b24f0-5a9e-4c43-8915-3f67d4332609")
+	response, err := client.Request(http.MethodGet, apiUrl, header, nil, nil)
+	if err != nil {
+		return
+	}
+	defer response.Body.Close()
+	fmt.Println(response.StatusCode)
+	if response.StatusCode != 200 {
+		fmt.Println("Error: ", response.StatusCode)
+		body, _ := io.ReadAll(response.Body)
+		fmt.Println(string(body))
+		return
+	}
+
+	type EnginesData struct {
+		Models []struct {
+			Slug         string   `json:"slug"`
+			MaxTokens    int      `json:"max_tokens"`
+			Title        string   `json:"title"`
+			Description  string   `json:"description"`
+			Tags         []string `json:"tags"`
+			Capabilities struct {
+			} `json:"capabilities,omitempty"`
+			ProductFeatures struct {
+			} `json:"product_features,omitempty"`
+		} `json:"models"`
+		Categories []struct {
+			Category             string `json:"category"`
+			HumanCategoryName    string `json:"human_category_name"`
+			SubscriptionLevel    string `json:"subscription_level"`
+			DefaultModel         string `json:"default_model"`
+			CodeInterpreterModel string `json:"code_interpreter_model,omitempty"`
+			PluginsModel         string `json:"plugins_model"`
+		} `json:"categories"`
+	}
+
+	var result EnginesData
+	json.NewDecoder(response.Body).Decode(&result)
+	fmt.Println(result)
+}

httpclient/resty/resty_client.go

@@ -0,0 +1,72 @@
+package resty
+
+import (
+	"aurora/util"
+	"crypto/tls"
+	browser "github.com/EDDYCJY/fake-useragent"
+	"github.com/go-resty/resty/v2"
+	"net/http"
+	"time"
+)
+
+type RestyClient struct {
+	Client *resty.Client
+}
+
+func NewStdClient() *RestyClient {
+	client := &RestyClient{
+		Client: resty.NewWithClient(&http.Client{
+			Transport: &http.Transport{
+				// 禁用长连接
+				DisableKeepAlives: true,
+				// 配置TLS设置，跳过证书验证
+				TLSClientConfig: &tls.Config{
+					InsecureSkipVerify: true,
+				},
+			},
+		}),
+	}
+	client.Client.SetBaseURL("https://chat.openai.com")
+	client.Client.SetRetryCount(3)
+	client.Client.SetRetryWaitTime(5 * time.Second)
+	client.Client.SetRetryMaxWaitTime(20 * time.Second)
+
+	client.Client.SetTimeout(600 * time.Second)
+	client.Client.SetHeader("user-agent", browser.Random()).
+		SetHeader("accept", "*/*").
+		SetHeader("accept-language", "en-US,en;q=0.9").
+		SetHeader("cache-control", "no-cache").
+		SetHeader("content-type", "application/json").
+		SetHeader("oai-language", util.RandomLanguage()).
+		SetHeader("pragma", "no-cache").
+		SetHeader("sec-ch-ua", `"Google Chrome";v="123", "Not:A-Brand";v="8", "Chromium";v="123"`).
+		SetHeader("sec-ch-ua-mobile", "?0").
+		SetHeader("sec-ch-ua-platform", "Windows").
+		SetHeader("sec-fetch-dest", "empty").
+		SetHeader("sec-fetch-mode", "cors").
+		SetHeader("sec-fetch-site", "same-origin")
+	return client
+}
+
+//func (c *RestyClient) Request(method string, url string, headers map[string]string, cookies []*http.Cookie, body io.Reader) (*http.Response, error) {
+//}
+
+//func (c *RestyClient) Post(url string, headers map[string]string, cookies []*http.Cookie, body io.Reader) (*http.Response, error) {
+//}
+//
+//func (c *RestyClient) Get(url string, headers map[string]string, cookies []*http.Cookie, body io.Reader) (*http.Response, error) {
+//}
+//
+//func (c *RestyClient) Head(url string, headers map[string]string, cookies []*http.Cookie, body io.Reader) (*http.Response, error) {
+//}
+//
+//func (c *RestyClient) Options(url string, headers map[string]string, cookies []*http.Cookie, body io.Reader) (*http.Response, error) {
+//}
+//
+//func (c *RestyClient) Put(url string, headers map[string]string, cookies []*http.Cookie, body io.Reader) (*http.Response, error) {
+//}
+//
+//func (c *RestyClient) Delete(url string, headers map[string]string, cookies []*http.Cookie, body io.Reader) (*http.Response, error) {
+//}
+//
+//func (c *RestyClient) SetProxy(url string) error {}

initialize/auth.go

@@ -0,0 +1,67 @@
+package initialize
+
+import (
+	"aurora/internal/tokens"
+	"bufio"
+	"fmt"
+	"os"
+	"strconv"
+
+	"github.com/google/uuid"
+)
+
+func readAccessToken() *tokens.AccessToken {
+	var Secrets []*tokens.Secret
+	// Read accounts.txt and create a list of accounts
+	if _, err := os.Stat("access_tokens.txt"); err == nil {
+		// Each line is a proxy, put in proxies array
+		file, _ := os.Open("access_tokens.txt")
+		defer file.Close()
+		scanner := bufio.NewScanner(file)
+		for scanner.Scan() {
+			// Split by :
+			token := scanner.Text()
+			if len(token) == 0 {
+				continue
+			}
+			// Append to accounts
+			Secrets = append(Secrets, tokens.NewSecret(token))
+		}
+	}
+
+	// 增加自定义free_tokens.txt，支持文件设置每个账号的uuid
+	if _, err := os.Stat("free_tokens.txt"); err == nil {
+		// Each line is a proxy, put in proxies array
+		file, _ := os.Open("free_tokens.txt")
+		defer file.Close()
+		scanner := bufio.NewScanner(file)
+		for scanner.Scan() {
+			// Split by :
+			token := scanner.Text()
+			if len(token) == 0 {
+				continue
+			}
+			// Append to accounts
+			Secrets = append(Secrets, tokens.NewSecretWithFree(token))
+		}
+	}
+
+	if os.Getenv("FREE_ACCOUNTS") == "" || os.Getenv("FREE_ACCOUNTS") == "true" {
+		freeAccountsNumStr := os.Getenv("FREE_ACCOUNTS_NUM")
+		numAccounts := 1024
+		if freeAccountsNumStr != "" {
+			if freeAccountsNum, err := strconv.Atoi(freeAccountsNumStr); err == nil && freeAccountsNum > 0 {
+				numAccounts = freeAccountsNum
+			} else {
+				fmt.Println("Invalid FREE_ACCOUNTS_NUM:", err)
+			}
+		}
+		for i := 0; i < numAccounts; i++ {
+			uid := uuid.NewString()
+			Secrets = append(Secrets, tokens.NewSecretWithFree(uid))
+		}
+	}
+
+	token := tokens.NewAccessToken(Secrets)
+	return &token
+}

initialize/handlers.go

@@ -0,0 +1,451 @@
+package initialize
+
+import (
+	chatgptrequestconverter "aurora/conversion/requests/chatgpt"
+	"aurora/duckgo"
+	"aurora/httpclient/bogdanfinn"
+	"aurora/internal/chatgpt"
+	"aurora/internal/proxys"
+	"aurora/internal/tokens"
+	chatgpt_types "aurora/typings/chatgpt"
+	officialtypes "aurora/typings/official"
+	"aurora/util"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+)
+
+type Handler struct {
+	proxy *proxys.IProxy
+	token *tokens.AccessToken
+}
+
+func NewHandle(proxy *proxys.IProxy, token *tokens.AccessToken) *Handler {
+	return &Handler{proxy: proxy, token: token}
+}
+
+func (h *Handler) refresh(c *gin.Context) {
+	var refreshToken officialtypes.OpenAIRefreshToken
+	err := c.BindJSON(&refreshToken)
+	if err != nil {
+		c.JSON(400, gin.H{"error": gin.H{
+			"message": "Request must be proper JSON",
+			"type":    "invalid_request_error",
+			"param":   nil,
+			"code":    err.Error(),
+		}})
+		return
+	}
+	proxyUrl := h.proxy.GetProxyIP()
+	client := bogdanfinn.NewStdClient()
+	openaiRefreshToken, status, err := chatgpt.GETTokenForRefreshToken(client, refreshToken.RefreshToken, proxyUrl)
+	if err != nil {
+		c.JSON(400, gin.H{
+			"message": "Request must be proper JSON",
+			"type":    "invalid_request_error",
+			"param":   nil,
+			"code":    err.Error(),
+		})
+		return
+	}
+	c.JSON(status, openaiRefreshToken)
+}
+
+func (h *Handler) session(c *gin.Context) {
+	var sessionToken officialtypes.OpenAISessionToken
+	err := c.BindJSON(&sessionToken)
+	if err != nil {
+		c.JSON(400, gin.H{
+			"message": "Request must be proper JSON",
+			"type":    "invalid_request_error",
+			"param":   nil,
+			"code":    err.Error(),
+		})
+		return
+	}
+	proxy_url := h.proxy.GetProxyIP()
+	client := bogdanfinn.NewStdClient()
+	openaiSessionToken, status, err := chatgpt.GETTokenForSessionToken(client, sessionToken.SessionToken, proxy_url)
+	if err != nil {
+		c.JSON(400, gin.H{"error": gin.H{
+			"message": "Request must be proper JSON",
+			"type":    "invalid_request_error",
+			"param":   nil,
+			"code":    err.Error(),
+		}})
+		return
+	}
+	c.JSON(status, openaiSessionToken)
+}
+
+func optionsHandler(c *gin.Context) {
+	// Set headers for CORS
+	c.Header("Access-Control-Allow-Origin", "*")
+	c.Header("Access-Control-Allow-Methods", "POST")
+	c.Header("Access-Control-Allow-Headers", "*")
+	c.JSON(200, gin.H{
+		"message": "pong",
+	})
+}
+
+func (h *Handler) refresh_handler(c *gin.Context) {
+	var refresh_token officialtypes.OpenAIRefreshToken
+	err := c.BindJSON(&refresh_token)
+	if err != nil {
+		c.JSON(400, gin.H{"error": gin.H{
+			"message": "Request must be proper JSON",
+			"type":    "invalid_request_error",
+			"param":   nil,
+			"code":    err.Error(),
+		}})
+		return
+	}
+
+	proxy_url := h.proxy.GetProxyIP()
+	client := bogdanfinn.NewStdClient()
+	openaiRefreshToken, status, err := chatgpt.GETTokenForRefreshToken(client, refresh_token.RefreshToken, proxy_url)
+	if err != nil {
+		c.JSON(400, gin.H{
+			"message": "Request must be proper JSON",
+			"type":    "invalid_request_error",
+			"param":   nil,
+			"code":    err.Error(),
+		})
+		return
+	}
+	c.JSON(status, openaiRefreshToken)
+}
+
+func (h *Handler) session_handler(c *gin.Context) {
+	var session_token officialtypes.OpenAISessionToken
+	err := c.BindJSON(&session_token)
+	if err != nil {
+		c.JSON(400, gin.H{
+			"message": "Request must be proper JSON",
+			"type":    "invalid_request_error",
+			"param":   nil,
+			"code":    err.Error(),
+		})
+		return
+	}
+	proxy_url := h.proxy.GetProxyIP()
+	client := bogdanfinn.NewStdClient()
+	openaiSessionToken, status, err := chatgpt.GETTokenForSessionToken(client, session_token.SessionToken, proxy_url)
+	if err != nil {
+		c.JSON(400, gin.H{"error": gin.H{
+			"message": "Request must be proper JSON",
+			"type":    "invalid_request_error",
+			"param":   nil,
+			"code":    err.Error(),
+		}})
+		return
+	}
+	c.JSON(status, openaiSessionToken)
+}
+
+func (h *Handler) duckduckgo(c *gin.Context) {
+	var original_request officialtypes.APIRequest
+	err := c.BindJSON(&original_request)
+	if err != nil {
+		c.JSON(400, gin.H{"error": gin.H{
+			"message": "Request must be proper JSON",
+			"type":    "invalid_request_error",
+			"param":   nil,
+			"code":    err.Error(),
+		}})
+		return
+	}
+	proxyUrl := h.proxy.GetProxyIP()
+	client := bogdanfinn.NewStdClient()
+	token, err := duckgo.InitXVQD(client, proxyUrl)
+	if err != nil {
+		c.JSON(500, gin.H{
+			"error": err.Error(),
+		})
+		return
+	}
+
+	translated_request := duckgo.ConvertAPIRequest(original_request)
+	response, err := duckgo.POSTconversation(client, translated_request, token, proxyUrl)
+	if err != nil {
+		c.JSON(500, gin.H{
+			"error": "request conversion error",
+		})
+		return
+	}
+
+	defer response.Body.Close()
+	if duckgo.Handle_request_error(c, response) {
+		return
+	}
+	var response_part string
+	response_part = duckgo.Handler(c, response, original_request.Stream)
+	if c.Writer.Status() != 200 {
+		return
+	}
+	if !original_request.Stream {
+		c.JSON(200, officialtypes.NewChatCompletionWithModel(response_part, translated_request.Model))
+	} else {
+		c.String(200, "data: [DONE]\n\n")
+	}
+
+}
+
+func (h *Handler) nightmare(c *gin.Context) {
+	var original_request officialtypes.APIRequest
+	err := c.BindJSON(&original_request)
+	input_tokens := util.CountToken(original_request.Messages[0].Content)
+	if err != nil {
+		c.JSON(400, gin.H{"error": gin.H{
+			"message": "Request must be proper JSON",
+			"type":    "invalid_request_error",
+			"param":   nil,
+			"code":    err.Error(),
+		}})
+		return
+	}
+	proxyUrl := h.proxy.GetProxyIP()
+	secret := h.token.GetSecret()
+	authHeader := c.GetHeader("Authorization")
+	if authHeader != "" {
+		customAccessToken := strings.Replace(authHeader, "Bearer ", "", 1)
+		if strings.HasPrefix(customAccessToken, "eyJhbGciOiJSUzI1NiI") {
+			secret = h.token.GenerateTempToken(customAccessToken)
+		}
+	}
+	if secret == nil {
+		c.JSON(400, gin.H{"error": "Not Account Found."})
+		c.Abort()
+		return
+	}
+
+	uid := uuid.NewString()
+	client := bogdanfinn.NewStdClient()
+	//err = chatgpt.InitCfClearance(proxyUrl)
+	//if err != nil {
+	//	c.JSON(500, gin.H{"error": err.Error()})
+	//	c.Abort()
+	//	return
+	//}
+	turnStile, status, err := chatgpt.InitTurnStile(client, secret, proxyUrl)
+	if err != nil {
+		c.JSON(status, gin.H{
+			"message": err.Error(),
+			"type":    "InitTurnStile_request_error",
+			"param":   err,
+			"code":    status,
+		})
+		return
+	}
+	if !secret.IsFree {
+		err = chatgpt.InitWSConn(client, secret.Token, uid, proxyUrl)
+		if err != nil {
+			c.JSON(500, gin.H{"error": "unable to create ws tunnel"})
+			return
+		}
+	}
+
+	// Convert the chat request to a ChatGPT request
+	translated_request := chatgptrequestconverter.ConvertAPIRequest(original_request, secret, turnStile.Arkose, proxyUrl)
+
+	response, err := chatgpt.POSTconversation(client, translated_request, secret, turnStile, proxyUrl)
+
+	if err != nil {
+		c.JSON(500, gin.H{
+			"error": "request conversion error",
+		})
+		return
+	}
+	defer response.Body.Close()
+	if chatgpt.Handle_request_error(c, response) {
+		return
+	}
+	var full_response string
+
+	if os.Getenv("STREAM_MODE") == "false" {
+		original_request.Stream = false
+	}
+	for i := 3; i > 0; i-- {
+		var continue_info *chatgpt.ContinueInfo
+		var response_part string
+		response_part, continue_info = chatgpt.Handler(c, response, client, secret, uid, translated_request, original_request.Stream)
+		full_response += response_part
+		if continue_info == nil {
+			break
+		}
+		translated_request.Messages = nil
+		translated_request.Action = "continue"
+		translated_request.ConversationID = continue_info.ConversationID
+		translated_request.ParentMessageID = continue_info.ParentID
+
+		if turnStile.Arkose {
+			chatgptrequestconverter.RenewTokenForRequest(&translated_request, secret.PUID, proxyUrl)
+		}
+		response, err = chatgpt.POSTconversation(client, translated_request, secret, turnStile, proxyUrl)
+
+		if err != nil {
+			c.JSON(500, gin.H{
+				"error": "request conversion error",
+			})
+			return
+		}
+		defer response.Body.Close()
+		if chatgpt.Handle_request_error(c, response) {
+			return
+		}
+	}
+	if c.Writer.Status() != 200 {
+		return
+	}
+	if !original_request.Stream {
+		output_tokens := util.CountToken(full_response)
+		c.JSON(200, officialtypes.NewChatCompletion(full_response, input_tokens, output_tokens))
+	} else {
+		c.String(200, "data: [DONE]\n\n")
+	}
+	chatgpt.UnlockSpecConn(secret.Token, uid)
+}
+
+func (h *Handler) engines(c *gin.Context) {
+	proxyUrl := h.proxy.GetProxyIP()
+	secret := h.token.GetSecret()
+	authHeader := c.GetHeader("Authorization")
+	if authHeader != "" {
+		customAccessToken := strings.Replace(authHeader, "Bearer ", "", 1)
+		// Check if customAccessToken starts with sk-
+		if strings.HasPrefix(customAccessToken, "eyJhbGciOiJSUzI1NiI") {
+			secret = h.token.GenerateTempToken(customAccessToken)
+		}
+	}
+	if secret == nil || secret.Token == "" {
+		c.JSON(400, gin.H{"error": "Not Account Found."})
+		return
+	}
+	client := bogdanfinn.NewStdClient()
+	resp, status, err := chatgpt.GETengines(client, secret, proxyUrl)
+	if err != nil {
+		c.JSON(500, gin.H{
+			"error": "error sending request",
+		})
+		return
+	}
+
+	type ResData struct {
+		ID      string `json:"id"`
+		Object  string `json:"object"`
+		Created int    `json:"created"`
+		OwnedBy string `json:"owned_by"`
+	}
+
+	type JSONData struct {
+		Object string    `json:"object"`
+		Data   []ResData `json:"data"`
+	}
+
+	modelS := JSONData{
+		Object: "list",
+	}
+	var resModelList []ResData
+	if len(resp.Models) > 2 {
+		res_data := ResData{
+			ID:      "gpt-4-mobile",
+			Object:  "model",
+			Created: 1685474247,
+			OwnedBy: "openai",
+		}
+		resModelList = append(resModelList, res_data)
+	}
+	for _, model := range resp.Models {
+		res_data := ResData{
+			ID:      model.Slug,
+			Object:  "model",
+			Created: 1685474247,
+			OwnedBy: "openai",
+		}
+		if model.Slug == "text-davinci-002-render-sha" {
+			res_data.ID = "gpt-3.5-turbo"
+		}
+		resModelList = append(resModelList, res_data)
+	}
+	modelS.Data = resModelList
+	c.JSON(status, modelS)
+}
+
+func (h *Handler) chatgptConversation(c *gin.Context) {
+	var original_request chatgpt_types.ChatGPTRequest
+	err := c.BindJSON(&original_request)
+	if err != nil {
+		c.JSON(400, gin.H{"error": gin.H{
+			"message": "Request must be proper JSON",
+			"type":    "invalid_request_error",
+			"param":   nil,
+			"code":    err.Error(),
+		}})
+		return
+	}
+	if original_request.Messages[0].Author.Role == "" {
+		original_request.Messages[0].Author.Role = "user"
+	}
+
+	proxyUrl := h.proxy.GetProxyIP()
+
+	var secret *tokens.Secret
+
+	isUUID := func(str string) bool {
+		_, err := uuid.Parse(str)
+		return err == nil
+	}
+
+	authHeader := c.GetHeader("Authorization")
+	if authHeader != "" {
+		customAccessToken := strings.Replace(authHeader, "Bearer ", "", 1)
+		if strings.HasPrefix(customAccessToken, "eyJhbGciOiJSUzI1NiI") {
+			secret = h.token.GenerateTempToken(customAccessToken)
+		}
+		if isUUID(customAccessToken) {
+			secret = h.token.GenerateDeviceId(customAccessToken)
+		}
+	}
+
+	if secret == nil {
+		secret = h.token.GetSecret()
+	}
+
+	client := bogdanfinn.NewStdClient()
+	turnStile, status, err := chatgpt.InitTurnStile(client, secret, proxyUrl)
+	if err != nil {
+		c.JSON(status, gin.H{
+			"message": err.Error(),
+			"type":    "InitTurnStile_request_error",
+			"param":   err,
+			"code":    status,
+		})
+		return
+	}
+
+	response, err := chatgpt.POSTconversation(client, original_request, secret, turnStile, proxyUrl)
+	if err != nil {
+		c.JSON(500, gin.H{
+			"error": "error sending request",
+		})
+		return
+	}
+	defer response.Body.Close()
+
+	if chatgpt.Handle_request_error(c, response) {
+		return
+	}
+
+	c.Header("Content-Type", response.Header.Get("Content-Type"))
+	if cacheControl := response.Header.Get("Cache-Control"); cacheControl != "" {
+		c.Header("Cache-Control", cacheControl)
+	}
+
+	_, err = io.Copy(c.Writer, response.Body)
+	if err != nil {
+		c.JSON(500, gin.H{"error": "Error sending response"})
+	}
+}

initialize/proxy.go

@@ -0,0 +1,48 @@
+package initialize
+
+import (
+	"aurora/internal/proxys"
+	"bufio"
+	"log/slog"
+	"net/url"
+	"os"
+)
+
+func checkProxy() *proxys.IProxy {
+	var proxies []string
+	proxyUrl := os.Getenv("PROXY_URL")
+	if proxyUrl != "" {
+		proxies = append(proxies, proxyUrl)
+	}
+
+	if _, err := os.Stat("proxies.txt"); err == nil {
+		file, _ := os.Open("proxies.txt")
+		defer file.Close()
+		scanner := bufio.NewScanner(file)
+		for scanner.Scan() {
+			proxy := scanner.Text()
+			parsedURL, err := url.Parse(proxy)
+			if err != nil {
+				slog.Warn("proxy url is invalid", "url", proxy, "err", err)
+				continue
+			}
+
+			// 如果缺少端口信息，不是完整的代理链接
+			if parsedURL.Port() != "" {
+				proxies = append(proxies, proxy)
+			} else {
+				continue
+			}
+		}
+	}
+
+	if len(proxies) == 0 {
+		proxy := os.Getenv("http_proxy")
+		if proxy != "" {
+			proxies = append(proxies, proxy)
+		}
+	}
+
+	proxyIP := proxys.NewIProxyIP(proxies)
+	return &proxyIP
+}

initialize/router.go

@@ -0,0 +1,39 @@
+package initialize
+
+import (
+	"aurora/middlewares"
+
+	"github.com/gin-gonic/gin"
+)
+
+func RegisterRouter() *gin.Engine {
+	handler := NewHandle(
+		checkProxy(),
+		readAccessToken(),
+	)
+
+	router := gin.Default()
+	router.Use(middlewares.Cors)
+
+	router.GET("/", func(c *gin.Context) {
+		c.JSON(200, gin.H{
+			"message": "Hello, world!",
+		})
+	})
+
+	router.GET("/ping", func(c *gin.Context) {
+		c.JSON(200, gin.H{
+			"message": "pong",
+		})
+	})
+
+	router.POST("/auth/session", handler.session)
+	router.POST("/auth/refresh", handler.refresh)
+	router.OPTIONS("/api/v1/chat/completions", optionsHandler)
+
+	authGroup := router.Group("").Use(middlewares.Authorization)
+	authGroup.POST("/api/v1/chat/completions", handler.duckduckgo)
+	authGroup.GET("/api/v1/models", handler.engines)
+	authGroup.POST("/backend-api/conversation", handler.chatgptConversation)
+	return router
+}

internal/chatgpt/request.go

@@ -0,0 +1,949 @@
+package chatgpt
+
+import (
+	"aurora/conversion/response/chatgpt"
+	"aurora/httpclient"
+	"aurora/internal/tokens"
+	"aurora/typings"
+	chatgpt_types "aurora/typings/chatgpt"
+	official_types "aurora/typings/official"
+	"aurora/util"
+	"bufio"
+	"bytes"
+	"context"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"math/rand"
+	"net/http"
+
+	"golang.org/x/crypto/sha3"
+
+	//http "github.com/bogdanfinn/fhttp"
+	"io"
+	"net/url"
+	"os"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+	"github.com/gorilla/websocket"
+	"github.com/joho/godotenv"
+)
+
+var BaseURL string
+
+func init() {
+	_ = godotenv.Load(".env")
+	BaseURL = os.Getenv("BASE_URL")
+	if BaseURL == "" {
+		BaseURL = "https://chat.openai.com/backend-anon"
+	}
+}
+
+type connInfo struct {
+	conn   *websocket.Conn
+	uuid   string
+	expire time.Time
+	ticker *time.Ticker
+	lock   bool
+}
+
+var (
+	API_REVERSE_PROXY   = os.Getenv("API_REVERSE_PROXY")
+	FILES_REVERSE_PROXY = os.Getenv("FILES_REVERSE_PROXY")
+	connPool            = map[string][]*connInfo{}
+	poolMutex           = sync.Mutex{}
+	TurnStilePool       = map[string]*TurnStile{}
+	userAgent           = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.0.0 Safari/537.36"
+	cores               = []int{8, 12, 16, 24}
+	screens             = []int{3000, 4000, 6000}
+	timeLocation, _     = time.LoadLocation("Asia/Shanghai")
+	timeLayout          = "Mon Jan 2 2006 15:04:05"
+	cf_clearance        *CfClearance
+)
+
+type CfClearance struct {
+	cfClearance string
+	ExpireAt    time.Time
+}
+
+func getWSURL(client httpclient.AuroraHttpClient, token string, retry int) (string, error) {
+	requestURL := BaseURL + "/register-websocket"
+	header := make(httpclient.AuroraHeaders)
+	header.Set("User-Agent", userAgent)
+	header.Set("Accept", "*/*")
+	header.Set("Oai-Language", "en-US")
+	if token != "" {
+		header.Set("Authorization", "Bearer "+token)
+	}
+	response, err := client.Request(http.MethodPost, requestURL, header, nil, nil)
+	if err != nil {
+		if retry > 3 {
+			return "", err
+		}
+		time.Sleep(time.Second) // wait 1s to get ws url
+		return getWSURL(client, token, retry+1)
+	}
+	defer response.Body.Close()
+	var WSSResp chatgpt_types.ChatGPTWSSResponse
+	err = json.NewDecoder(response.Body).Decode(&WSSResp)
+	if err != nil {
+		return "", err
+	}
+	return WSSResp.WssUrl, nil
+}
+
+func createWSConn(client httpclient.AuroraHttpClient, url string, connInfo *connInfo, retry int) error {
+	dialer := websocket.DefaultDialer
+	dialer.EnableCompression = true
+	dialer.Subprotocols = []string{"json.reliable.webpubsub.azure.v1"}
+	conn, _, err := dialer.Dial(url, nil)
+	if err != nil {
+		if retry > 3 {
+			return err
+		}
+		time.Sleep(time.Second) // wait 1s to recreate ws
+		return createWSConn(client, url, connInfo, retry+1)
+	}
+	connInfo.conn = conn
+	connInfo.expire = time.Now().Add(time.Minute * 30)
+	ticker := time.NewTicker(time.Second * 8)
+	connInfo.ticker = ticker
+	go func(ticker *time.Ticker) {
+		defer ticker.Stop()
+		for {
+			<-ticker.C
+			if err := connInfo.conn.WriteMessage(websocket.PingMessage, []byte{}); err != nil {
+				connInfo.conn.Close()
+				connInfo.conn = nil
+				break
+			}
+		}
+	}(ticker)
+	return nil
+}
+
+func findAvailConn(token string, uuid string) *connInfo {
+	for _, value := range connPool[token] {
+		if !value.lock {
+			value.lock = true
+			value.uuid = uuid
+			return value
+		}
+	}
+	newConnInfo := connInfo{uuid: uuid, lock: true}
+	connPool[token] = append(connPool[token], &newConnInfo)
+	return &newConnInfo
+}
+func findSpecConn(token string, uuid string) *connInfo {
+	for _, value := range connPool[token] {
+		if value.uuid == uuid {
+			return value
+		}
+	}
+	return &connInfo{}
+}
+func UnlockSpecConn(token string, uuid string) {
+	for _, value := range connPool[token] {
+		if value.uuid == uuid {
+			value.lock = false
+		}
+	}
+}
+
+func InitWSConn(client httpclient.AuroraHttpClient, token string, uuid string, proxy string) error {
+	connInfo := findAvailConn(token, uuid)
+	conn := connInfo.conn
+	isExpired := connInfo.expire.IsZero() || time.Now().After(connInfo.expire)
+	if conn == nil || isExpired {
+		if proxy != "" {
+			client.SetProxy(proxy)
+		}
+		if conn != nil {
+			connInfo.ticker.Stop()
+			conn.Close()
+			connInfo.conn = nil
+		}
+		wssURL, err := getWSURL(client, token, 0)
+		if err != nil {
+			return err
+		}
+		err = createWSConn(client, wssURL, connInfo, 0)
+		if err != nil {
+			return err
+		}
+		return nil
+	} else {
+		ctx, cancelFunc := context.WithTimeout(context.Background(), time.Millisecond*100)
+		go func() {
+			defer cancelFunc()
+			for {
+				_, _, err := conn.NextReader()
+				if err != nil {
+					break
+				}
+				if ctx.Err() != nil {
+					break
+				}
+			}
+		}()
+		<-ctx.Done()
+		err := ctx.Err()
+		if err != nil {
+			switch err {
+			case context.Canceled:
+				connInfo.ticker.Stop()
+				conn.Close()
+				connInfo.conn = nil
+				connInfo.lock = false
+				return InitWSConn(client, token, uuid, proxy)
+			case context.DeadlineExceeded:
+				return nil
+			default:
+				return nil
+			}
+		}
+		return nil
+	}
+}
+
+type ChatRequire struct {
+	Token  string `json:"token"`
+	Arkose struct {
+		Required bool   `json:"required"`
+		DX       string `json:"dx,omitempty"`
+	} `json:"arkose"`
+
+	Turnstile struct {
+		Required bool `json:"required"`
+	}
+}
+
+type TurnStile struct {
+	TurnStileToken   string
+	ProofOfWorkToken string
+	Arkose           bool
+	ExpireAt         time.Time
+}
+
+type ProofWork struct {
+	Difficulty string `json:"difficulty,omitempty"`
+	Required   bool   `json:"required"`
+	Seed       string `json:"seed,omitempty"`
+}
+
+func getParseTime() string {
+	now := time.Now()
+	now = now.In(timeLocation)
+	return now.Format(timeLayout) + " GMT+0800 (中国标准时间)"
+}
+func getConfig() []interface{} {
+	rand.New(rand.NewSource(time.Now().UnixNano()))
+	core := cores[rand.Intn(4)]
+	rand.New(rand.NewSource(time.Now().UnixNano()))
+	screen := screens[rand.Intn(3)]
+	return []interface{}{core + screen, getParseTime(), int64(4294705152), 0, userAgent}
+
+}
+func CalcProofToken(seed string, diff string) string {
+	config := getConfig()
+	diffLen := len(diff) / 2
+	hasher := sha3.New512()
+	for i := 0; i < 100000; i++ {
+		config[3] = i
+		json, _ := json.Marshal(config)
+		base := base64.StdEncoding.EncodeToString(json)
+		hasher.Write([]byte(seed + base))
+		hash := hasher.Sum(nil)
+		hasher.Reset()
+		if hex.EncodeToString(hash[:diffLen]) <= diff {
+			return "gAAAAAB" + base
+		}
+	}
+	return "gAAAAABwQ8Lk5FbGpA2NcR9dShT6gYjU7VxZ4D" + base64.StdEncoding.EncodeToString([]byte(`"`+seed+`"`))
+}
+
+func InitCfClearance(proxy string) error {
+	poolMutex.Lock()
+	defer poolMutex.Unlock()
+	if cf_clearance == nil || cf_clearance.ExpireAt.Before(time.Now()) {
+		resp, err := getCf(proxy)
+		if err != nil {
+			return err
+		}
+		cf_clearance = &CfClearance{
+			cfClearance: resp,
+			ExpireAt:    time.Now().Add(30 * time.Minute),
+		}
+	}
+	return nil
+}
+
+func InitTurnStile(client httpclient.AuroraHttpClient, secret *tokens.Secret, proxy string) (*TurnStile, int, error) {
+	poolMutex.Lock()
+	defer poolMutex.Unlock()
+	currTurnToken := TurnStilePool[secret.Token]
+	if currTurnToken == nil || currTurnToken.ExpireAt.Before(time.Now()) {
+		response, err := POSTTurnStile(client, secret, proxy, 0)
+		if err != nil {
+			return nil, http.StatusInternalServerError, err
+		}
+		defer response.Body.Close()
+		if response.StatusCode != 200 {
+			return nil, response.StatusCode, fmt.Errorf("failed to get chat requirements")
+		}
+		var result chatgpt_types.RequirementsResponse
+		if err := json.NewDecoder(response.Body).Decode(&result); err != nil {
+			return nil, response.StatusCode, err
+		}
+
+		currTurnToken = &TurnStile{
+			TurnStileToken: result.Token,
+			Arkose:         result.Arkose.Required,
+			ExpireAt:       time.Now().Add(5 * time.Second),
+		}
+		if result.Proof.Required == true {
+			currTurnToken.ProofOfWorkToken = CalcProofToken(result.Proof.Seed, result.Proof.Difficulty)
+		}
+
+		// 如果是免登账号，将其放入池子
+		if secret.IsFree {
+			TurnStilePool[secret.Token] = currTurnToken
+		}
+	}
+	return currTurnToken, 0, nil
+}
+func POSTTurnStile(client httpclient.AuroraHttpClient, secret *tokens.Secret, proxy string, retry int) (*http.Response, error) {
+	if proxy != "" {
+		client.SetProxy(proxy)
+	}
+	apiUrl := BaseURL + "/sentinel/chat-requirements"
+	payload := strings.NewReader(`{"conversation_mode_kind":"primary_assistant"}`)
+
+	header := createBaseHeader()
+	header.Set("content-type", "application/json")
+	if !secret.IsFree && secret.Token != "" {
+		header.Set("Authorization", "Bearer "+secret.Token)
+	}
+	if secret.IsFree {
+		header.Set("oai-device-id", secret.Token)
+	}
+	var cookie *http.Cookie
+	// 补全伪装环境参数，无实质用处。
+	cookie = &http.Cookie{Name: "cf_clearance", Value: cf_clearance.cfClearance}
+	response, err := client.Request(http.MethodPost, apiUrl, header, []*http.Cookie{cookie}, payload)
+	if err != nil {
+		return &http.Response{}, err
+	}
+	if response.StatusCode == 401 && secret.IsFree {
+		if retry > 3 {
+			return response, err
+		}
+		time.Sleep(time.Second * 2)
+		secret.Token = uuid.NewString()
+		return POSTTurnStile(client, secret, proxy, retry+1)
+	}
+	return response, err
+}
+
+var urlAttrMap = make(map[string]string)
+
+type urlAttr struct {
+	Url         string `json:"url"`
+	Attribution string `json:"attribution"`
+}
+
+func getURLAttribution(client httpclient.AuroraHttpClient, access_token string, puid string, url string) string {
+	requestURL := BaseURL + "/attributions"
+	payload := bytes.NewBuffer([]byte(`{"urls":["` + url + `"]}`))
+	header := createBaseHeader()
+	if puid != "" {
+		header.Set("Cookie", "_puid="+puid+";")
+	}
+	header.Set("Content-Type", "application/json")
+	if access_token != "" {
+		header.Set("Authorization", "Bearer "+access_token)
+	}
+	response, err := client.Request(http.MethodPost, requestURL, header, nil, payload)
+	if err != nil {
+		return ""
+	}
+	defer response.Body.Close()
+	var attr urlAttr
+	err = json.NewDecoder(response.Body).Decode(&attr)
+	if err != nil {
+		return ""
+	}
+	return attr.Attribution
+}
+
+func getCf(proxy string) (string, error) {
+	client := &http.Client{}
+	if proxy != "" {
+		client.Transport = &http.Transport{
+			Proxy: func(req *http.Request) (*url.URL, error) {
+				return url.Parse(proxy)
+			},
+		}
+	}
+
+	var data = strings.NewReader(`{}`)
+	req, err := http.NewRequest("POST", "https://chat.openai.com/cdn-cgi/challenge-platform/h/b/jsd/r/"+util.RandomHexadecimalString(), data)
+	if err != nil {
+		return "", err
+	}
+	req.Header.Set("accept", "*/*")
+	req.Header.Set("accept-language", "zh-CN,zh;q=0.9")
+	req.Header.Set("content-type", "application/json")
+	req.Header.Set("origin", "https://chat.openai.com")
+	req.Header.Set("sec-ch-ua", `"Google Chrome";v="123", "Not:A-Brand";v="8", "Chromium";v="123"`)
+	req.Header.Set("sec-ch-ua-mobile", "?0")
+	req.Header.Set("sec-ch-ua-platform", `"Windows"`)
+	req.Header.Set("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.0.0 Safari/537.36")
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != 200 {
+		return "", errors.New("failed to get cf clearance")
+	}
+	for _, cookie := range resp.Cookies() {
+		if cookie.Name == "cf_clearance" {
+			return cookie.Value, nil
+		}
+	}
+	return "", errors.New("ailed to get cf clearance")
+}
+
+func POSTconversation(client httpclient.AuroraHttpClient, message chatgpt_types.ChatGPTRequest, secret *tokens.Secret, chat_token *TurnStile, proxy string) (*http.Response, error) {
+	if proxy != "" {
+		client.SetProxy(proxy)
+	}
+	apiUrl := BaseURL + "/conversation"
+	if API_REVERSE_PROXY != "" {
+		apiUrl = API_REVERSE_PROXY
+	}
+	arkoseToken := message.ArkoseToken
+	message.ArkoseToken = ""
+
+	// JSONify the body and add it to the request
+	body_json, err := json.Marshal(message)
+	if err != nil {
+		return &http.Response{}, err
+	}
+	header := createBaseHeader()
+	header.Set("content-type", "application/json")
+	// Clear cookies
+	if secret.PUID != "" {
+		header.Set("Cookie", "_puid="+secret.PUID+";")
+	}
+	if chat_token.Arkose {
+		header.Set("openai-sentinel-arkose-token", arkoseToken)
+	}
+	if chat_token.TurnStileToken != "" {
+		header.Set("Openai-Sentinel-Chat-Requirements-Token", chat_token.TurnStileToken)
+	}
+	if chat_token.ProofOfWorkToken != "" {
+		header.Set("Openai-Sentinel-Proof-Token", chat_token.ProofOfWorkToken)
+	}
+	if !secret.IsFree && secret.Token != "" {
+		header.Set("Authorization", "Bearer "+secret.Token)
+	}
+	if secret.IsFree {
+		header.Set("oai-device-id", secret.Token)
+	}
+	var cookie *http.Cookie
+	// 补全伪装环境参数，无实质用处。
+	cookie = &http.Cookie{Name: "cf_clearance", Value: cf_clearance.cfClearance}
+	response, err := client.Request(http.MethodPost, apiUrl, header, []*http.Cookie{cookie}, bytes.NewBuffer(body_json))
+	if err != nil {
+		return nil, err
+	}
+	return response, nil
+}
+
+type EnginesData struct {
+	Models []struct {
+		Slug         string   `json:"slug"`
+		MaxTokens    int      `json:"max_tokens"`
+		Title        string   `json:"title"`
+		Description  string   `json:"description"`
+		Tags         []string `json:"tags"`
+		Capabilities struct {
+		} `json:"capabilities,omitempty"`
+		ProductFeatures struct {
+		} `json:"product_features,omitempty"`
+	} `json:"models"`
+	Categories []struct {
+		Category             string `json:"category"`
+		HumanCategoryName    string `json:"human_category_name"`
+		SubscriptionLevel    string `json:"subscription_level"`
+		DefaultModel         string `json:"default_model"`
+		CodeInterpreterModel string `json:"code_interpreter_model,omitempty"`
+		PluginsModel         string `json:"plugins_model"`
+	} `json:"categories"`
+}
+
+func GETengines(client httpclient.AuroraHttpClient, secret *tokens.Secret, proxy string) (*EnginesData, int, error) {
+	if proxy != "" {
+		client.SetProxy(proxy)
+	}
+	reqUrl := BaseURL + "/models"
+	header := make(httpclient.AuroraHeaders)
+	header.Set("Content-Type", "application/json")
+	header.Set("User-Agent", userAgent)
+	header.Set("Accept", "*/*")
+	header.Set("oai-language", "en-US")
+	header.Set("origin", "https://chat.openai.com")
+	header.Set("referer", "https://chat.openai.com/")
+
+	if !secret.IsFree && secret.Token != "" {
+		header.Set("Authorization", "Bearer "+secret.Token)
+	}
+	if secret.IsFree {
+		header.Set("Oai-Device-Id", secret.Token)
+	}
+	if secret.PUID != "" {
+		header.Set("Cookie", "_puid="+secret.PUID+";")
+	}
+	resp, err := client.Request(http.MethodGet, reqUrl, header, nil, nil)
+	if err != nil {
+		return nil, 0, err
+	}
+	defer resp.Body.Close()
+
+	var result EnginesData
+	json.NewDecoder(resp.Body).Decode(&result)
+	return &result, resp.StatusCode, nil
+}
+
+func Handle_request_error(c *gin.Context, response *http.Response) bool {
+	if response.StatusCode != 200 {
+		// Try read response body as JSON
+		var error_response map[string]interface{}
+		err := json.NewDecoder(response.Body).Decode(&error_response)
+		if err != nil {
+			// Read response body
+			body, _ := io.ReadAll(response.Body)
+			c.JSON(response.StatusCode, gin.H{"error": gin.H{
+				"message": "Unknown error",
+				"type":    "internal_server_error",
+				"param":   nil,
+				"code":    "500",
+				"details": string(body),
+			}})
+			return true
+		}
+		c.JSON(response.StatusCode, gin.H{"error": gin.H{
+			"message": error_response["detail"],
+			"type":    response.Status,
+			"param":   nil,
+			"code":    "error",
+		}})
+		return true
+	}
+	return false
+}
+
+type ContinueInfo struct {
+	ConversationID string `json:"conversation_id"`
+	ParentID       string `json:"parent_id"`
+}
+
+type fileInfo struct {
+	DownloadURL string `json:"download_url"`
+	Status      string `json:"status"`
+}
+
+func GetImageSource(client httpclient.AuroraHttpClient, wg *sync.WaitGroup, url string, prompt string, token string, puid string, idx int, imgSource []string) {
+	defer wg.Done()
+	header := make(httpclient.AuroraHeaders)
+	// Clear cookies
+	if puid != "" {
+		header.Set("Cookie", "_puid="+puid+";")
+	}
+	header.Set("User-Agent", userAgent)
+	header.Set("Accept", "*/*")
+	if token != "" {
+		header.Set("Authorization", "Bearer "+token)
+	}
+	response, err := client.Request(http.MethodGet, url, header, nil, nil)
+	if err != nil {
+		return
+	}
+	defer response.Body.Close()
+	var file_info fileInfo
+	err = json.NewDecoder(response.Body).Decode(&file_info)
+	if err != nil || file_info.Status != "success" {
+		return
+	}
+	imgSource[idx] = "[![image](" + file_info.DownloadURL + " \"" + prompt + "\")](" + file_info.DownloadURL + ")"
+}
+
+func Handler(c *gin.Context, response *http.Response, client httpclient.AuroraHttpClient, secret *tokens.Secret, uuid string, translated_request chatgpt_types.ChatGPTRequest, stream bool) (string, *ContinueInfo) {
+	max_tokens := false
+
+	// Create a bufio.Reader from the response body
+	reader := bufio.NewReader(response.Body)
+
+	// Read the response byte by byte until a newline character is encountered
+	if stream {
+		// Response content type is text/event-stream
+		c.Header("Content-Type", "text/event-stream")
+	} else {
+		// Response content type is application/json
+		c.Header("Content-Type", "application/json")
+	}
+	var finish_reason string
+	var previous_text typings.StringStruct
+	var original_response chatgpt_types.ChatGPTResponse
+	var isRole = true
+	var waitSource = false
+	var isEnd = false
+	var imgSource []string
+	var isWSS = false
+	var convId string
+	var respId string
+	var wssUrl string
+	var connInfo *connInfo
+	var wsSeq int
+	var isWSInterrupt bool = false
+	var interruptTimer *time.Timer
+
+	if !strings.Contains(response.Header.Get("Content-Type"), "text/event-stream") {
+		isWSS = true
+		connInfo = findSpecConn(secret.Token, uuid)
+		if connInfo.conn == nil {
+			c.JSON(500, gin.H{"error": "No websocket connection"})
+			return "", nil
+		}
+		var wssResponse chatgpt_types.ChatGPTWSSResponse
+		json.NewDecoder(response.Body).Decode(&wssResponse)
+		wssUrl = wssResponse.WssUrl
+		respId = wssResponse.ResponseId
+		convId = wssResponse.ConversationId
+	}
+	for {
+		var line string
+		var err error
+		if isWSS {
+			var messageType int
+			var message []byte
+			if isWSInterrupt {
+				if interruptTimer == nil {
+					interruptTimer = time.NewTimer(10 * time.Second)
+				}
+				select {
+				case <-interruptTimer.C:
+					c.JSON(500, gin.H{"error": "WS interrupt & new WS timeout"})
+					return "", nil
+				default:
+					goto reader
+				}
+			}
+		reader:
+			messageType, message, err = connInfo.conn.ReadMessage()
+			if err != nil {
+				connInfo.ticker.Stop()
+				connInfo.conn.Close()
+				connInfo.conn = nil
+				err := createWSConn(client, wssUrl, connInfo, 0)
+				if err != nil {
+					c.JSON(500, gin.H{"error": err.Error()})
+					return "", nil
+				}
+				isWSInterrupt = true
+				connInfo.conn.WriteMessage(websocket.TextMessage, []byte("{\"type\":\"sequenceAck\",\"sequenceId\":"+strconv.Itoa(wsSeq)+"}"))
+				continue
+			}
+			if messageType == websocket.TextMessage {
+				var wssMsgResponse chatgpt_types.WSSMsgResponse
+				json.Unmarshal(message, &wssMsgResponse)
+				if wssMsgResponse.Data.ResponseId != respId {
+					continue
+				}
+				wsSeq = wssMsgResponse.SequenceId
+				if wsSeq%50 == 0 {
+					connInfo.conn.WriteMessage(websocket.TextMessage, []byte("{\"type\":\"sequenceAck\",\"sequenceId\":"+strconv.Itoa(wsSeq)+"}"))
+				}
+				base64Body := wssMsgResponse.Data.Body
+				bodyByte, err := base64.StdEncoding.DecodeString(base64Body)
+				if err != nil {
+					continue
+				}
+				if isWSInterrupt {
+					isWSInterrupt = false
+					interruptTimer.Stop()
+				}
+				line = string(bodyByte)
+			}
+		} else {
+			line, err = reader.ReadString('\n')
+			if err != nil {
+				if err == io.EOF {
+					break
+				}
+				return "", nil
+			}
+		}
+		if len(line) < 6 {
+			continue
+		}
+		// Remove "data: " from the beginning of the line
+		line = line[6:]
+		// Check if line starts with [DONE]
+		if !strings.HasPrefix(line, "[DONE]") {
+			// Parse the line as JSON
+			err = json.Unmarshal([]byte(line), &original_response)
+			if err != nil {
+				continue
+			}
+			if original_response.Error != nil {
+				c.JSON(500, gin.H{"error": original_response.Error})
+				return "", nil
+			}
+			if original_response.ConversationID != convId {
+				if convId == "" {
+					convId = original_response.ConversationID
+				} else {
+					continue
+				}
+			}
+			if !(original_response.Message.Author.Role == "assistant" || (original_response.Message.Author.Role == "tool" && original_response.Message.Content.ContentType != "text")) || original_response.Message.Content.Parts == nil {
+				continue
+			}
+			if original_response.Message.Metadata.MessageType == "" {
+				continue
+			}
+			if original_response.Message.Metadata.MessageType != "next" && original_response.Message.Metadata.MessageType != "continue" || !strings.HasSuffix(original_response.Message.Content.ContentType, "text") {
+				continue
+			}
+			if original_response.Message.EndTurn != nil {
+				if waitSource {
+					waitSource = false
+				}
+				isEnd = true
+			}
+			if len(original_response.Message.Metadata.Citations) != 0 {
+				r := []rune(original_response.Message.Content.Parts[0].(string))
+				if waitSource {
+					if string(r[len(r)-1:]) == "】" {
+						waitSource = false
+					} else {
+						continue
+					}
+				}
+				offset := 0
+				for _, citation := range original_response.Message.Metadata.Citations {
+					rl := len(r)
+					attr := urlAttrMap[citation.Metadata.URL]
+					if attr == "" {
+						u, _ := url.Parse(citation.Metadata.URL)
+						BaseURL := u.Scheme + "://" + u.Host + "/"
+						attr = getURLAttribution(client, secret.Token, secret.PUID, BaseURL)
+						if attr != "" {
+							urlAttrMap[citation.Metadata.URL] = attr
+						}
+					}
+					original_response.Message.Content.Parts[0] = string(r[:citation.StartIx+offset]) + " ([" + attr + "](" + citation.Metadata.URL + " \"" + citation.Metadata.Title + "\"))" + string(r[citation.EndIx+offset:])
+					r = []rune(original_response.Message.Content.Parts[0].(string))
+					offset += len(r) - rl
+				}
+			} else if waitSource {
+				continue
+			}
+			response_string := ""
+			if original_response.Message.Recipient != "all" {
+				continue
+			}
+			if original_response.Message.Content.ContentType == "multimodal_text" {
+				apiUrl := BaseURL + "/files/"
+				if FILES_REVERSE_PROXY != "" {
+					apiUrl = FILES_REVERSE_PROXY
+				}
+				imgSource = make([]string, len(original_response.Message.Content.Parts))
+				var wg sync.WaitGroup
+				for index, part := range original_response.Message.Content.Parts {
+					jsonItem, _ := json.Marshal(part)
+					var dalle_content chatgpt_types.DalleContent
+					err = json.Unmarshal(jsonItem, &dalle_content)
+					if err != nil {
+						continue
+					}
+					url := apiUrl + strings.Split(dalle_content.AssetPointer, "//")[1] + "/download"
+					wg.Add(1)
+					go GetImageSource(client, &wg, url, dalle_content.Metadata.Dalle.Prompt, secret.Token, secret.PUID, index, imgSource)
+				}
+				wg.Wait()
+				translated_response := official_types.NewChatCompletionChunk(strings.Join(imgSource, ""))
+				if isRole {
+					translated_response.Choices[0].Delta.Role = original_response.Message.Author.Role
+				}
+				response_string = "data: " + translated_response.String() + "\n\n"
+			}
+			if response_string == "" {
+				response_string = chatgpt.ConvertToString(&original_response, &previous_text, isRole)
+			}
+			if response_string == "" {
+				if isEnd {
+					goto endProcess
+				} else {
+					continue
+				}
+			}
+			if response_string == "【" {
+				waitSource = true
+				continue
+			}
+		endProcess:
+			isRole = false
+			if stream {
+				_, err = c.Writer.WriteString(response_string)
+				if err != nil {
+					return "", nil
+				}
+				c.Writer.Flush()
+			}
+
+			if original_response.Message.Metadata.FinishDetails != nil {
+				if original_response.Message.Metadata.FinishDetails.Type == "max_tokens" {
+					max_tokens = true
+				}
+				finish_reason = original_response.Message.Metadata.FinishDetails.Type
+			}
+			if isEnd {
+				if stream {
+					final_line := official_types.StopChunk(finish_reason)
+					c.Writer.WriteString("data: " + final_line.String() + "\n\n")
+				}
+				break
+			}
+		}
+	}
+	if !max_tokens {
+		return strings.Join(imgSource, "") + previous_text.Text, nil
+	}
+	return strings.Join(imgSource, "") + previous_text.Text, &ContinueInfo{
+		ConversationID: original_response.ConversationID,
+		ParentID:       original_response.Message.ID,
+	}
+}
+
+type AuthSession struct {
+	User struct {
+		Id           string        `json:"id"`
+		Name         string        `json:"name"`
+		Email        string        `json:"email"`
+		Image        string        `json:"image"`
+		Picture      string        `json:"picture"`
+		Idp          string        `json:"idp"`
+		Iat          int           `json:"iat"`
+		Mfa          bool          `json:"mfa"`
+		Groups       []interface{} `json:"groups"`
+		IntercomHash string        `json:"intercom_hash"`
+	} `json:"user"`
+	Expires      time.Time `json:"expires"`
+	AccessToken  string    `json:"accessToken"`
+	AuthProvider string    `json:"authProvider"`
+}
+
+func GETTokenForRefreshToken(client httpclient.AuroraHttpClient, refresh_token string, proxy string) (interface{}, int, error) {
+	if proxy != "" {
+		client.SetProxy(proxy)
+	}
+	rawUrl := "https://auth0.openai.com/oauth/token"
+
+	data := map[string]interface{}{
+		"redirect_uri":  "com.openai.chat://auth0.openai.com/ios/com.openai.chat/callback",
+		"grant_type":    "refresh_token",
+		"client_id":     "pdlLIX2Y72MIl2rhLhTE9VV9bN905kBh",
+		"refresh_token": refresh_token,
+	}
+
+	reqBody, err := json.Marshal(data)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	header := make(httpclient.AuroraHeaders)
+	//req, _ := http.NewRequest("POST", url, bytes.NewBuffer(reqBody))
+	header.Set("authority", "auth0.openai.com")
+	header.Set("Accept-Language", "en-US,en;q=0.9")
+	header.Set("Content-Type", "application/json")
+	header.Set("User-Agent", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36")
+	header.Set("Accept", "*/*")
+	resp, err := client.Request(http.MethodPost, rawUrl, header, nil, bytes.NewBuffer(reqBody))
+	if err != nil {
+		return nil, 0, err
+	}
+	defer resp.Body.Close()
+	var result interface{}
+	err = json.NewDecoder(resp.Body).Decode(&result)
+	if err != nil {
+		return nil, 0, err
+	}
+	return result, resp.StatusCode, nil
+}
+
+func GETTokenForSessionToken(client httpclient.AuroraHttpClient, session_token string, proxy string) (interface{}, int, error) {
+	if proxy != "" {
+		client.SetProxy(proxy)
+	}
+	url := "https://chat.openai.com/api/auth/session"
+	header := make(httpclient.AuroraHeaders)
+	header.Set("authority", "chat.openai.com")
+	header.Set("accept-language", "zh-CN,zh;q=0.9")
+	header.Set("User-Agent", userAgent)
+	header.Set("Accept", "*/*")
+	header.Set("oai-language", "en-US")
+	header.Set("origin", "https://chat.openai.com")
+	header.Set("referer", "https://chat.openai.com/")
+	header.Set("cookie", "__Secure-next-auth.session-token="+session_token)
+	resp, err := client.Request(http.MethodGet, url, header, nil, nil)
+	if err != nil {
+		return nil, 0, err
+	}
+	defer resp.Body.Close()
+	var result AuthSession
+	json.NewDecoder(resp.Body).Decode(&result)
+
+	cookies := parseCookies(resp.Cookies())
+	if value, ok := cookies["__Secure-next-auth.session-token"]; ok {
+		session_token = value
+	}
+	openai_sessionToken := official_types.NewOpenAISessionToken(session_token, result.AccessToken)
+	return openai_sessionToken, resp.StatusCode, nil
+}
+
+func parseCookies(cookies []*http.Cookie) map[string]string {
+	cookieDict := make(map[string]string)
+	for _, cookie := range cookies {
+		cookieDict[cookie.Name] = cookie.Value
+	}
+	return cookieDict
+}
+
+func createBaseHeader() httpclient.AuroraHeaders {
+	header := make(httpclient.AuroraHeaders)
+	// 完善补充完整的请求头
+	header.Set("accept", "*/*")
+	header.Set("accept-language", "en-US,en;q=0.9")
+	header.Set("oai-language", util.RandomLanguage())
+	header.Set("origin", "https://chat.openai.com")
+	header.Set("referer", "https://chat.openai.com/")
+	header.Set("sec-ch-ua", `"Google Chrome";v="44", "Not:A-Brand";v="8", "Chromium";v="44"`)
+	header.Set("sec-ch-ua-mobile", "?0")
+	header.Set("sec-ch-ua-platform", `"Linux"`)
+	header.Set("sec-fetch-dest", "empty")
+	header.Set("sec-fetch-mode", "cors")
+	header.Set("sec-fetch-site", "same-origin")
+	header.Set("user-agent", userAgent)
+	return header
+}

internal/proxys/proxys.go

@@ -0,0 +1,35 @@
+package proxys
+
+import "sync"
+
+type IProxy struct {
+	ips  []string
+	lock sync.Mutex
+}
+
+func NewIProxyIP(ips []string) IProxy {
+	return IProxy{
+		ips: ips,
+	}
+}
+
+func (p *IProxy) GetIPS() int {
+	return len(p.ips)
+}
+
+func (p *IProxy) GetProxyIP() string {
+	if p == nil {
+		return ""
+	}
+
+	p.lock.Lock()
+	defer p.lock.Unlock()
+
+	if len(p.ips) == 0 {
+		return ""
+	}
+
+	proxyIp := p.ips[0]
+	p.ips = append(p.ips[1:], proxyIp)
+	return proxyIp
+}

internal/tokens/tokens.go

@@ -0,0 +1,64 @@
+package tokens
+
+import (
+	"sync"
+)
+
+type Secret struct {
+	Token  string `json:"token"`
+	PUID   string `json:"puid"`
+	IsFree bool   `json:"isFree"`
+}
+type AccessToken struct {
+	tokens []*Secret
+	lock   sync.Mutex
+}
+
+func NewSecret(token string) *Secret {
+	return &Secret{Token: token, PUID: "", IsFree: false}
+}
+
+func NewSecretWithFree(token string) *Secret {
+	return &Secret{Token: token, PUID: "", IsFree: true}
+}
+
+func NewAccessToken(tokens []*Secret) AccessToken {
+	return AccessToken{
+		tokens: tokens,
+	}
+}
+
+func (a *AccessToken) GetSecret() *Secret {
+	if a == nil {
+		return &Secret{}
+	}
+
+	a.lock.Lock()
+	defer a.lock.Unlock()
+
+	if len(a.tokens) == 0 {
+		return &Secret{}
+	}
+
+	secret := a.tokens[0]
+	a.tokens = append(a.tokens[1:], secret)
+	return secret
+}
+
+// UpdateSecret 更新tokens
+func (a *AccessToken) UpdateSecret(tokens []*Secret) {
+	a.lock.Lock()
+	defer a.lock.Unlock()
+	if len(tokens) == 0 {
+		return
+	}
+	a.tokens = tokens
+}
+
+func (a *AccessToken) GenerateTempToken(token string) *Secret {
+	return &Secret{Token: token, PUID: "", IsFree: false}
+}
+
+func (a *AccessToken) GenerateDeviceId(token string) *Secret {
+	return &Secret{Token: token, PUID: "", IsFree: true}
+}

main.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+	"aurora/initialize"
+	"embed"
+	"io/fs"
+	"log"
+	"net/http"
+	"os"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/acheong08/endless"
+	"github.com/joho/godotenv"
+)
+
+//go:embed web/*
+var staticFiles embed.FS
+
+func main() {
+	gin.SetMode(gin.ReleaseMode)
+	router := initialize.RegisterRouter()
+	subFS, err := fs.Sub(staticFiles, "web")
+	if err != nil {
+		log.Fatal(err)
+	}
+	router.StaticFS("/web", http.FS(subFS))
+
+	_ = godotenv.Load(".env")
+	host := os.Getenv("SERVER_HOST")
+	port := os.Getenv("SERVER_PORT")
+	tlsCert := os.Getenv("TLS_CERT")
+	tlsKey := os.Getenv("TLS_KEY")
+
+	if host == "" {
+		host = "0.0.0.0"
+	}
+	if port == "" {
+		port = os.Getenv("PORT")
+		if port == "" {
+			port = "8080"
+		}
+	}
+
+	if tlsCert != "" && tlsKey != "" {
+		_ = endless.ListenAndServeTLS(host+":"+port, tlsCert, tlsKey, router)
+	} else {
+		_ = endless.ListenAndServe(host+":"+port, router)
+	}
+}

middlewares/auth.go

@@ -0,0 +1,31 @@
+package middlewares
+
+import (
+	"github.com/gin-gonic/gin"
+	"os"
+	"strings"
+)
+
+func Authorization(c *gin.Context) {
+	customer_key := os.Getenv("Authorization")
+	if customer_key != "" {
+		authHeader := c.GetHeader("Authorization")
+		if authHeader == "" {
+			c.JSON(401, gin.H{"error": "Unauthorized"})
+			c.Abort()
+			return
+		}
+		tokenParts := strings.Split(strings.Replace(authHeader, "Bearer ", "", 1)," ")
+		customAccessToken := tokenParts[0]
+		if customer_key != customAccessToken {
+			c.JSON(401, gin.H{"error": "Unauthorized"})
+			c.Abort()
+			return
+		}
+		if len(tokenParts) > 1 {
+			openaiAccessToken := tokenParts[1]
+			c.Request.Header.Set("Authorization", "Bearer " + openaiAccessToken)
+		}
+	}
+	c.Next()
+}

middlewares/cors.go

@@ -0,0 +1,10 @@
+package middlewares
+
+import "github.com/gin-gonic/gin"
+
+func Cors(c *gin.Context) {
+	c.Header("Access-Control-Allow-Origin", "*")
+	c.Header("Access-Control-Allow-Methods", "*")
+	c.Header("Access-Control-Allow-Headers", "*")
+	c.Next()
+}

release.bat

@@ -0,0 +1,56 @@
+@echo off
+SETLOCAL
+
+REM 指定编码为 UTF-8
+chcp 65001
+
+REM 设置要生成的可执行文件的名称
+set OUTPUT_NAME=aurora
+
+REM 设置 Go 源文件的名称
+SET GOFILE=aurora
+
+REM 设置输出目录
+SET OUTPUTDIR=target
+
+REM 确保输出目录存在
+IF NOT EXIST %OUTPUTDIR% MKDIR %OUTPUTDIR%
+
+REM 编译为 Windows/amd64
+echo 开始编译 Windows/amd64
+SET GOOS=windows
+SET GOARCH=amd64
+go build -o %OUTPUTDIR%/%OUTPUT_NAME%_windows_amd64.exe %GOFILE%
+echo 编译完成 Windows/amd64
+
+REM 编译为 Windows/386
+echo 开始编译 Windows/386
+SET GOOS=windows
+SET GOARCH=386
+go build -o %OUTPUTDIR%/%OUTPUT_NAME%_windows_386.exe %GOFILE%
+echo 编译完成 Windows/386
+
+REM 编译为 Linux/amd64
+echo 开始编译 Linux/amd64
+SET GOOS=linux
+SET GOARCH=amd64
+go build -o %OUTPUTDIR%/%OUTPUT_NAME%_linux_amd64 %GOFILE%
+echo 编译完成 Linux/amd64
+
+REM 编译为 macOS/amd64
+echo 开始编译 macOS/amd64
+SET GOOS=darwin
+SET GOARCH=amd64
+go build -o %OUTPUTDIR%/%OUTPUT_NAME%_macos_amd64 %GOFILE%
+echo 编译完成 macOS/amd64
+
+REM 编译为 freebsd/amd64
+echo 开始编译 freebsd/amd64
+SET GOOS=freebsd
+SET GOARCH=amd64
+go build -o %OUTPUTDIR%/%OUTPUT_NAME%_freebsd_amd64 %GOFILE%
+echo 编译完成 freebsd/amd64
+
+REM 结束批处理脚本
+ENDLOCAL
+echo 编译完成!

render.yaml

@@ -0,0 +1,7 @@
+services:
+  - type: web
+    name: aurora
+    env: docker
+    dockerfilePath: ./Dockerfile
+    plan: free
+

typings/chatgpt/request.go

@@ -0,0 +1,51 @@
+package chatgpt
+
+import (
+	"os"
+
+	"github.com/google/uuid"
+)
+
+type chatgpt_message struct {
+	ID      uuid.UUID       `json:"id"`
+	Author  chatgpt_author  `json:"author"`
+	Content chatgpt_content `json:"content"`
+}
+
+type chatgpt_content struct {
+	ContentType string   `json:"content_type"`
+	Parts       []string `json:"parts"`
+}
+
+type chatgpt_author struct {
+	Role string `json:"role"`
+}
+
+type ChatGPTRequest struct {
+	Action                     string            `json:"action"`
+	Messages                   []chatgpt_message `json:"messages,omitempty"`
+	ParentMessageID            string            `json:"parent_message_id,omitempty"`
+	ConversationID             string            `json:"conversation_id,omitempty"`
+	Model                      string            `json:"model"`
+	HistoryAndTrainingDisabled bool              `json:"history_and_training_disabled"`
+	ArkoseToken                string            `json:"arkose_token,omitempty"`
+	PluginIDs                  []string          `json:"plugin_ids,omitempty"`
+}
+
+func NewChatGPTRequest() ChatGPTRequest {
+	disable_history := os.Getenv("ENABLE_HISTORY") != "true"
+	return ChatGPTRequest{
+		Action:                     "next",
+		ParentMessageID:            uuid.NewString(),
+		Model:                      "text-davinci-002-render-sha",
+		HistoryAndTrainingDisabled: disable_history,
+	}
+}
+
+func (c *ChatGPTRequest) AddMessage(role string, content string) {
+	c.Messages = append(c.Messages, chatgpt_message{
+		ID:      uuid.New(),
+		Author:  chatgpt_author{Role: role},
+		Content: chatgpt_content{ContentType: "text", Parts: []string{content}},
+	})
+}

typings/chatgpt/response.go

@@ -0,0 +1,98 @@
+package chatgpt
+
+type ChatGPTResponse struct {
+	Message        Message     `json:"message"`
+	ConversationID string      `json:"conversation_id"`
+	Error          interface{} `json:"error"`
+}
+type ChatGPTWSSResponse struct {
+	WssUrl         string `json:"wss_url"`
+	ConversationId string `json:"conversation_id,omitempty"`
+	ResponseId     string `json:"response_id,omitempty"`
+}
+
+type WSSMsgResponse struct {
+	SequenceId int                `json:"sequenceId"`
+	Type       string             `json:"type"`
+	From       string             `json:"from"`
+	DataType   string             `json:"dataType"`
+	Data       WSSMsgResponseData `json:"data"`
+}
+
+type WSSMsgResponseData struct {
+	Type           string `json:"type"`
+	Body           string `json:"body"`
+	MoreBody       bool   `json:"more_body"`
+	ResponseId     string `json:"response_id"`
+	ConversationId string `json:"conversation_id"`
+}
+
+type Message struct {
+	ID         string      `json:"id"`
+	Author     Author      `json:"author"`
+	CreateTime float64     `json:"create_time"`
+	UpdateTime interface{} `json:"update_time"`
+	Content    Content     `json:"content"`
+	EndTurn    interface{} `json:"end_turn"`
+	Weight     float64     `json:"weight"`
+	Metadata   Metadata    `json:"metadata"`
+	Recipient  string      `json:"recipient"`
+}
+
+type Content struct {
+	ContentType string        `json:"content_type"`
+	Parts       []interface{} `json:"parts"`
+}
+
+type Author struct {
+	Role     string                 `json:"role"`
+	Name     interface{}            `json:"name"`
+	Metadata map[string]interface{} `json:"metadata"`
+}
+
+type Metadata struct {
+	Timestamp     string         `json:"timestamp_"`
+	Citations     []Citation     `json:"citations,omitempty"`
+	MessageType   string         `json:"message_type"`
+	FinishDetails *FinishDetails `json:"finish_details"`
+	ModelSlug     string         `json:"model_slug"`
+}
+type Citation struct {
+	Metadata CitaMeta `json:"metadata"`
+	StartIx  int      `json:"start_ix"`
+	EndIx    int      `json:"end_ix"`
+}
+type CitaMeta struct {
+	URL   string `json:"url"`
+	Title string `json:"title"`
+}
+type FinishDetails struct {
+	Type string `json:"type"`
+	Stop string `json:"stop"`
+}
+type DalleContent struct {
+	AssetPointer string `json:"asset_pointer"`
+	Metadata     struct {
+		Dalle struct {
+			Prompt string `json:"prompt"`
+		} `json:"dalle"`
+	} `json:"metadata"`
+}
+
+type ProofWork struct {
+	Difficulty string `json:"difficulty,omitempty"`
+	Required   bool   `json:"required"`
+	Seed       string `json:"seed,omitempty"`
+}
+
+type RequirementsResponse struct {
+	Arkose struct {
+		Required bool        `json:"required"`
+		Dx       interface{} `json:"dx"`
+	} `json:"arkose"`
+	Proof     ProofWork `json:"proofofwork,omitempty"`
+	Turnstile struct {
+		Required bool `json:"required"`
+	} `json:"turnstile"`
+	Token string `json:"token"`
+}

typings/official/request.go

@@ -0,0 +1,21 @@
+package official
+
+type APIRequest struct {
+	Messages  []api_message `json:"messages"`
+	Stream    bool          `json:"stream"`
+	Model     string        `json:"model"`
+	PluginIDs []string      `json:"plugin_ids"`
+}
+
+type api_message struct {
+	Role    string `json:"role"`
+	Content string `json:"content"`
+}
+
+type OpenAISessionToken struct {
+	SessionToken string `json:"session_token"`
+}
+
+type OpenAIRefreshToken struct {
+	RefreshToken string `json:"refresh_token"`
+}

typings/official/response.go

@@ -0,0 +1,174 @@
+package official
+
+import "encoding/json"
+
+type ChatCompletionChunk struct {
+	ID      string    `json:"id"`
+	Object  string    `json:"object"`
+	Created int64     `json:"created"`
+	Model   string    `json:"model"`
+	Choices []Choices `json:"choices"`
+}
+
+func (chunk *ChatCompletionChunk) String() string {
+	resp, _ := json.Marshal(chunk)
+	return string(resp)
+}
+
+type Choices struct {
+	Delta        Delta       `json:"delta"`
+	Index        int         `json:"index"`
+	FinishReason interface{} `json:"finish_reason"`
+}
+
+type Delta struct {
+	Content string `json:"content,omitempty"`
+	Role    string `json:"role,omitempty"`
+}
+
+func NewChatCompletionChunk(text string) ChatCompletionChunk {
+	return ChatCompletionChunk{
+		ID:      "chatcmpl-QXlha2FBbmROaXhpZUFyZUF3ZXNvbWUK",
+		Object:  "chat.completion.chunk",
+		Created: 0,
+		Model:   "gpt-3.5-turbo-0301",
+		Choices: []Choices{
+			{
+				Index: 0,
+				Delta: Delta{
+					Content: text,
+				},
+				FinishReason: nil,
+			},
+		},
+	}
+}
+
+func NewChatCompletionChunkWithModel(text string, model string) ChatCompletionChunk {
+	return ChatCompletionChunk{
+		ID:      "chatcmpl-QXlha2FBbmROaXhpZUFyZUF3ZXNvbWUK",
+		Object:  "chat.completion.chunk",
+		Created: 0,
+		Model:   model,
+		Choices: []Choices{
+			{
+				Index: 0,
+				Delta: Delta{
+					Content: text,
+				},
+				FinishReason: nil,
+			},
+		},
+	}
+}
+
+func StopChunkWithModel(reason string, model string) ChatCompletionChunk {
+	return ChatCompletionChunk{
+		ID:      "chatcmpl-QXlha2FBbmROaXhpZUFyZUF3ZXNvbWUK",
+		Object:  "chat.completion.chunk",
+		Created: 0,
+		Model:   model,
+		Choices: []Choices{
+			{
+				Index:        0,
+				FinishReason: reason,
+			},
+		},
+	}
+}
+
+func StopChunk(reason string) ChatCompletionChunk {
+	return ChatCompletionChunk{
+		ID:      "chatcmpl-QXlha2FBbmROaXhpZUFyZUF3ZXNvbWUK",
+		Object:  "chat.completion.chunk",
+		Created: 0,
+		Model:   "gpt-3.5-turbo-0125",
+		Choices: []Choices{
+			{
+				Index:        0,
+				FinishReason: reason,
+			},
+		},
+	}
+}
+
+type ChatCompletion struct {
+	ID      string   `json:"id"`
+	Object  string   `json:"object"`
+	Created int64    `json:"created"`
+	Model   string   `json:"model"`
+	Usage   usage    `json:"usage"`
+	Choices []Choice `json:"choices"`
+}
+type Msg struct {
+	Role    string `json:"role"`
+	Content string `json:"content"`
+}
+type Choice struct {
+	Index        int         `json:"index"`
+	Message      Msg         `json:"message"`
+	FinishReason interface{} `json:"finish_reason"`
+}
+type usage struct {
+	PromptTokens     int `json:"prompt_tokens"`
+	CompletionTokens int `json:"completion_tokens"`
+	TotalTokens      int `json:"total_tokens"`
+}
+
+func NewChatCompletionWithModel(text string, model string) ChatCompletion {
+	return ChatCompletion{
+		ID:      "chatcmpl-QXlha2FBbmROaXhpZUFyZUF3ZXNvbWUK",
+		Object:  "chat.completion",
+		Created: int64(0),
+		Model:   model,
+		Usage: usage{
+			PromptTokens:     0,
+			CompletionTokens: 0,
+			TotalTokens:      0,
+		},
+		Choices: []Choice{
+			{
+				Message: Msg{
+					Content: text,
+					Role:    "assistant",
+				},
+				Index: 0,
+			},
+		},
+	}
+}
+
+func NewChatCompletion(full_test string, input_tokens, output_tokens int) ChatCompletion {
+	return ChatCompletion{
+		ID:      "chatcmpl-QXlha2FBbmROaXhpZUFyZUF3ZXNvbWUK",
+		Object:  "chat.completion",
+		Created: int64(0),
+		Model:   "gpt-3.5-turbo-0125",
+		Usage: usage{
+			PromptTokens:     input_tokens,
+			CompletionTokens: output_tokens,
+			TotalTokens:      input_tokens + output_tokens,
+		},
+		Choices: []Choice{
+			{
+				Message: Msg{
+					Content: full_test,
+					Role:    "assistant",
+				},
+				Index: 0,
+			},
+		},
+	}
+}
+
+type OpenAIAccessTokenWithSession struct {
+	SessionToken string `json:"session_token"`
+	AccessToken  string `json:"access_token"`
+}
+
+func NewOpenAISessionToken(session_token string, access_token string) *OpenAIAccessTokenWithSession {
+	return &OpenAIAccessTokenWithSession{
+		SessionToken: session_token,
+		AccessToken:  access_token,
+	}
+}

typings/typings.go

@@ -0,0 +1,10 @@
+package typings
+
+type GenericResponseLine struct {
+	Line  string `json:"line"`
+	Error string `json:"error"`
+}
+
+type StringStruct struct {
+	Text string `json:"text"`
+}

util/util.go

@@ -0,0 +1,53 @@
+package util
+
+import (
+	"github.com/pkoukk/tiktoken-go"
+	"log/slog"
+	"math/rand"
+	"time"
+)
+
+func RandomLanguage() string {
+	// 初始化随机数生成器
+	rand.Seed(time.Now().UnixNano())
+	// 语言列表
+	languages := []string{"af", "am", "ar-sa", "as", "az-Latn", "be", "bg", "bn-BD", "bn-IN", "bs", "ca", "ca-ES-valencia", "cs", "cy", "da", "de", "de-de", "el", "en-GB", "en-US", "es", "es-ES", "es-US", "es-MX", "et", "eu", "fa", "fi", "fil-Latn", "fr", "fr-FR", "fr-CA", "ga", "gd-Latn", "gl", "gu", "ha-Latn", "he", "hi", "hr", "hu", "hy", "id", "ig-Latn", "is", "it", "it-it", "ja", "ka", "kk", "km", "kn", "ko", "kok", "ku-Arab", "ky-Cyrl", "lb", "lt", "lv", "mi-Latn", "mk", "ml", "mn-Cyrl", "mr", "ms", "mt", "nb", "ne", "nl", "nl-BE", "nn", "nso", "or", "pa", "pa-Arab", "pl", "prs-Arab", "pt-BR", "pt-PT", "qut-Latn", "quz", "ro", "ru", "rw", "sd-Arab", "si", "sk", "sl", "sq", "sr-Cyrl-BA", "sr-Cyrl-RS", "sr-Latn-RS", "sv", "sw", "ta", "te", "tg-Cyrl", "th", "ti", "tk-Latn", "tn", "tr", "tt-Cyrl", "ug-Arab", "uk", "ur", "uz-Latn", "vi", "wo", "xh", "yo-Latn", "zh-Hans", "zh-Hant", "zu"}
+	// 随机选择一个语言
+	randomIndex := rand.Intn(len(languages))
+	return languages[randomIndex]
+}
+
+func RandomHexadecimalString() string {
+	rand.Seed(time.Now().UnixNano())
+	const charset = "0123456789abcdef"
+	const length = 16 // The length of the string you want to generate
+	b := make([]byte, length)
+	for i := range b {
+		b[i] = charset[rand.Intn(len(charset))]
+	}
+	return string(b)
+}
+func CountToken(input string) int {
+	encoding := "gpt-3.5-turbo"
+	tkm, err := tiktoken.EncodingForModel(encoding)
+	if err != nil {
+		slog.Warn("tiktoken.EncodingForModel error:", err)
+		return 0
+	}
+	token := tkm.Encode(input, nil, nil)
+	return len(token)
+}
+
+func RandomIntStr(num int) string {
+	rand.Seed(time.Now().UnixNano())
+	const charset = "0123456789"
+	var length = 16 // The length of the string you want to generate
+	if num > 0 {
+		length = num
+	}
+	b := make([]byte, length)
+	for i := range b {
+		b[i] = charset[rand.Intn(len(charset))]
+	}
+	return string(b)
+}

util/utils_test.go

@@ -0,0 +1,16 @@
+package util
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestRandomHexadecimalString(t *testing.T) {
+	var str = RandomHexadecimalString()
+	fmt.Println(str)
+}
+
+func TestRandomIntStr(t *testing.T) {
+	var str = RandomIntStr(39)
+	fmt.Println(str)
+}

vercel.json

@@ -0,0 +1,8 @@
+{
+  "routes": [
+    {
+      "src": "/.*",
+      "dest": "/api/router.go"
+    }
+  ]
+}