Merge branch 'xqdoo00o-master' into Add-Gemini

auth.go

@@ -16,15 +16,15 @@ import (
 	"github.com/xqdoo00o/OpenAIAuth/auth"
 )
 
-var accounts []Account
+var accounts map[string]AccountInfo
 
 var validAccounts []string
 
 const interval = time.Hour * 24
 
-type Account struct {
-	Email    string `json:"username"`
+type AccountInfo struct {
 	Password string `json:"password"`
+	Times    []int  `json:"times"`
 }
 
 type TokenExp struct {
@@ -57,19 +57,36 @@ func AppendIfNone(slice []string, i string) []string {
 	return append(slice, i)
 }
 
+var TimesCounter int
+
 func getSecret() (string, tokens.Secret) {
 	if len(validAccounts) != 0 {
 		account := validAccounts[0]
-		validAccounts = append(validAccounts[1:], account)
-		return account, ACCESS_TOKENS.GetSecret(account)
+		secret := ACCESS_TOKENS.GetSecret(account)
+		if TimesCounter == 0 {
+			TimesCounter = accounts[account].Times[0]
+			if secret.TeamUserID != "" && len(accounts[account].Times) == 2 {
+				TimesCounter += accounts[account].Times[1]
+			}
+		}
+		TimesCounter--
+		if TimesCounter == 0 {
+			validAccounts = append(validAccounts[1:], account)
+		}
+		if secret.TeamUserID != "" {
+			if TimesCounter < accounts[account].Times[0] {
+				secret.TeamUserID = ""
+			}
+		}
+		return account, secret
 	} else {
 		return "", tokens.Secret{}
 	}
 }
 
 // Read accounts.txt and create a list of accounts
 func readAccounts() {
-	accounts = []Account{}
+	accounts = map[string]AccountInfo{}
 	// Read accounts.txt and create a list of accounts
 	if _, err := os.Stat("accounts.txt"); err == nil {
 		// Each line is a proxy, put in proxies array
@@ -79,23 +96,38 @@ func readAccounts() {
 		for scanner.Scan() {
 			// Split by :
 			line := strings.Split(scanner.Text(), ":")
-			if len(line) < 2 {
+			length := len(line)
+			if length < 2 {
 				continue
 			}
+			var times []int
+			if length == 2 {
+				times = append(times, 1)
+			} else {
+				timeStrs := strings.Split(line[2], "/")
+				for i := 0; i < len(timeStrs); i++ {
+					time, err := strconv.Atoi(timeStrs[i])
+					if i == 2 || err != nil || time < 1 {
+						break
+					}
+					times = append(times, time)
+				}
+				if len(times) == 0 {
+					times = append(times, 1)
+				}
+			}
 			// Create an account
-			account := Account{
-				Email:    line[0],
+			accounts[line[0]] = AccountInfo{
 				Password: line[1],
+				Times:    times,
 			}
-			// Append to accounts
-			accounts = append(accounts, account)
 		}
 	}
 }
 
-func newTimeFunc(account Account, token_list map[string]tokens.Secret, cron bool) func() {
+func newTimeFunc(email string, password string, token_list map[string]tokens.Secret, cron bool) func() {
 	return func() {
-		updateSingleToken(account, token_list, cron)
+		updateSingleToken(email, password, token_list, cron)
 	}
 }
 
@@ -127,28 +159,28 @@ func scheduleTokenPUID() {
 		} else {
 			ACCESS_TOKENS = tokens.NewAccessToken(token_list)
 			validAccounts = []string{}
-			for _, account := range accounts {
-				token := token_list[account.Email].Token
+			for account, info := range accounts {
+				token := token_list[account].Token
 				if token == "" {
-					updateSingleToken(account, nil, true)
+					updateSingleToken(account, info.Password, nil, true)
 				} else {
 					var toPUIDExpire time.Duration
 					var puidTime time.Time
 					var toExpire time.Duration
-					if token_list[account.Email].PUID != "" {
+					if token_list[account].PUID != "" {
 						re := regexp.MustCompile(`\d{10,}`)
-						puidIat := re.FindString(token_list[account.Email].PUID)
+						puidIat := re.FindString(token_list[account].PUID)
 						if puidIat != "" {
 							puidIatInt, _ := strconv.ParseInt(puidIat, 10, 64)
 							puidTime = time.Unix(puidIatInt, 0)
 							toPUIDExpire = interval - time.Since(puidTime)
 							if toPUIDExpire < 0 {
-								updateSingleToken(account, nil, false)
+								updateSingleToken(account, info.Password, nil, false)
 							}
 						}
 					}
 				tokenProcess:
-					token = ACCESS_TOKENS.GetSecret(account.Email).Token
+					token = ACCESS_TOKENS.GetSecret(account).Token
 					expireTime, err := getTokenExpire(token)
 					nowTime := time.Now()
 					if err != nil {
@@ -162,32 +194,32 @@ func scheduleTokenPUID() {
 					if toPUIDExpire > 0 {
 						toPUIDExpire = interval - nowTime.Sub(puidTime)
 						if toExpire-toPUIDExpire > 2e9 {
-							updateSingleToken(account, nil, false)
+							updateSingleToken(account, info.Password, nil, false)
 							toPUIDExpire = 0
 							goto tokenProcess
 						}
 					}
 					if toExpire > 0 {
-						validAccounts = AppendIfNone(validAccounts, account.Email)
-						f := newTimeFunc(account, nil, true)
+						validAccounts = AppendIfNone(validAccounts, account)
+						f := newTimeFunc(account, info.Password, nil, true)
 						time.AfterFunc(toExpire+time.Second, f)
 					} else {
-						updateSingleToken(account, nil, true)
+						updateSingleToken(account, info.Password, nil, true)
 					}
 				}
 			}
 		}
 	}
 }
 
-func updateSingleToken(account Account, token_list map[string]tokens.Secret, cron bool) {
+func updateSingleToken(email string, password string, token_list map[string]tokens.Secret, cron bool) {
 	if os.Getenv("CF_PROXY") != "" {
 		// exec warp-cli disconnect and connect
 		exec.Command("warp-cli", "disconnect").Run()
 		exec.Command("warp-cli", "connect").Run()
 		time.Sleep(5 * time.Second)
 	}
-	println("Updating access token for " + account.Email)
+	println("Updating access token for " + email)
 	var proxy_url string
 	if len(proxies) == 0 {
 		proxy_url = ""
@@ -196,16 +228,16 @@ func updateSingleToken(account Account, token_list map[string]tokens.Secret, cro
 		// Push used proxy to the back of the list
 		proxies = append(proxies[1:], proxies[0])
 	}
-	authenticator := auth.NewAuthenticator(account.Email, account.Password, proxy_url)
+	authenticator := auth.NewAuthenticator(email, password, proxy_url)
 	err := authenticator.RenewWithCookies()
 	if err != nil {
 		authenticator.ResetCookies()
 		err := authenticator.Begin()
 		if err != nil {
 			if token_list == nil {
-				ACCESS_TOKENS.Delete(account.Email)
+				ACCESS_TOKENS.Delete(email)
 				for i, v := range validAccounts {
-					if v == account.Email {
+					if v == email {
 						validAccounts = append(validAccounts[:i], validAccounts[i+1:]...)
 						break
 					}
@@ -219,20 +251,21 @@ func updateSingleToken(account Account, token_list map[string]tokens.Secret, cro
 	}
 	access_token := authenticator.GetAccessToken()
 	puid, _ := authenticator.GetPUID()
+	teamUserID, _ := authenticator.GetTeamUserID()
 	if token_list != nil {
-		token_list[account.Email] = tokens.Secret{Token: access_token, PUID: puid}
+		token_list[email] = tokens.Secret{Token: access_token, PUID: puid, TeamUserID: teamUserID}
 	} else {
-		ACCESS_TOKENS.Set(account.Email, access_token, puid)
+		ACCESS_TOKENS.Set(email, access_token, puid, teamUserID)
 		ACCESS_TOKENS.Save()
 	}
-	validAccounts = AppendIfNone(validAccounts, account.Email)
+	validAccounts = AppendIfNone(validAccounts, email)
 	println("Success!")
 	err = authenticator.SaveCookies()
 	if err != nil {
 		println(err.Details)
 	}
 	if cron {
-		f := newTimeFunc(account, token_list, cron)
+		f := newTimeFunc(email, password, token_list, cron)
 		time.AfterFunc(interval+time.Second, f)
 	}
 }
@@ -241,8 +274,8 @@ func updateToken() {
 	token_list := map[string]tokens.Secret{}
 	validAccounts = []string{}
 	// Loop through each account
-	for _, account := range accounts {
-		updateSingleToken(account, token_list, false)
+	for account, info := range accounts {
+		updateSingleToken(account, info.Password, token_list, false)
 	}
 	// Append access token to access_tokens.json
 	ACCESS_TOKENS = tokens.NewAccessToken(token_list)

conversion/requests/chatgpt/convert.go

@@ -22,6 +22,14 @@ func ConvertAPIRequest(api_request official_types.APIRequest, account string, se
 	} else if strings.HasPrefix(api_request.Model, "gpt-4") {
 		api_version = 4
 		chatgpt_request.Model = "gpt-4"
+		if len(api_request.Model) > 12 {
+			key := api_request.Model[6:11]
+			if key == "gizmo" {
+				val := api_request.Model[12:]
+				chatgpt_request.ConversationMode.Kind = "gizmo_interaction"
+				chatgpt_request.ConversationMode.GizmoId = val
+			}
+		}
 	}
 	if requireArk {
 		token, err := arkose.GetOpenAIToken(api_version, secret.PUID, dx, proxy)
@@ -31,10 +39,6 @@ func ConvertAPIRequest(api_request official_types.APIRequest, account string, se
 			fmt.Println("Error getting Arkose token: ", err)
 		}
 	}
-	if api_request.PluginIDs != nil {
-		chatgpt_request.PluginIDs = api_request.PluginIDs
-		chatgpt_request.Model = "gpt-4-plugins"
-	}
 	ifMultimodel := api_version == 4
 	for _, api_message := range api_request.Messages {
 		if api_message.Role == "system" {

go.mod

@@ -17,9 +17,10 @@ require (
 	github.com/joho/godotenv v1.5.1
 	github.com/sashabaranov/go-openai v1.21.0
 	github.com/tidwall/gjson v1.17.1
-	github.com/xqdoo00o/OpenAIAuth v0.0.0-20240403091529-7ef147706fc4
+	github.com/xqdoo00o/OpenAIAuth v0.0.0-20240420184134-706a5d60f6c1
 	github.com/xqdoo00o/funcaptcha v0.0.0-20240403090732-1b604d808f6c
 	github.com/zhu327/gemini-openai-proxy v0.0.0-20240328042054-d2c6c4cdff01
+	golang.org/x/crypto v0.22.0
 	golang.org/x/image v0.15.0
 	google.golang.org/api v0.172.0
 	k8s.io/apimachinery v0.29.3
@@ -74,7 +75,6 @@ require (
 	go.opentelemetry.io/otel/metric v1.25.0 // indirect
 	go.opentelemetry.io/otel/trace v1.25.0 // indirect
 	golang.org/x/arch v0.7.0 // indirect
-	golang.org/x/crypto v0.22.0 // indirect
 	golang.org/x/exp v0.0.0-20240409090435-93d18d7e34b8 // indirect
 	golang.org/x/net v0.24.0 // indirect
 	golang.org/x/oauth2 v0.19.0 // indirect

go.sum

@@ -176,8 +176,8 @@ github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS
 github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
 github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
-github.com/xqdoo00o/OpenAIAuth v0.0.0-20240403091529-7ef147706fc4 h1:Goj6yoMgADshscKkfhRpDeMxyGm2wdcHCUPj0YQ+B3c=
-github.com/xqdoo00o/OpenAIAuth v0.0.0-20240403091529-7ef147706fc4/go.mod h1:XHxG7wI3Erk4nS0rwjXVF3FllYW5QxsRynnJ0GqAMCQ=
+github.com/xqdoo00o/OpenAIAuth v0.0.0-20240420184134-706a5d60f6c1 h1:pSzLMgRZ8G9f6qytVm/OL97hD+qSTvhceSzDhW7SRbY=
+github.com/xqdoo00o/OpenAIAuth v0.0.0-20240420184134-706a5d60f6c1/go.mod h1:XHxG7wI3Erk4nS0rwjXVF3FllYW5QxsRynnJ0GqAMCQ=
 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=

handlers.go

@@ -166,7 +166,7 @@ func nightmare(c *gin.Context) {
 		wg.Add(2)
 		go func() {
 			defer wg.Done()
-			err = chatgpt.InitWSConn(secret.Token, deviceId, uid, proxy_url)
+			err = chatgpt.InitWSConn(&secret, deviceId, uid, proxy_url)
 		}()
 	}
 	go func() {
@@ -182,10 +182,14 @@ func nightmare(c *gin.Context) {
 		c.JSON(500, gin.H{"error": "unable to check chat requirement"})
 		return
 	}
+	var proofToken string
+	if chat_require.Proof.Required {
+		proofToken = chatgpt.CalcProofToken(chat_require.Proof.Seed, chat_require.Proof.Difficulty)
+	}
 	// Convert the chat request to a ChatGPT request
 	translated_request := chatgpt_request_converter.ConvertAPIRequest(original_request, account, &secret, deviceId, chat_require.Arkose.Required, chat_require.Arkose.DX, proxy_url)
 
-	response, err := chatgpt.POSTconversation(translated_request, &secret, deviceId, chat_require.Token, proxy_url)
+	response, err := chatgpt.POSTconversation(translated_request, &secret, deviceId, chat_require.Token, proofToken, proxy_url)
 	if err != nil {
 		c.JSON(500, gin.H{
 			"error": "error sending request",
@@ -213,7 +217,7 @@ func nightmare(c *gin.Context) {
 		if chat_require.Arkose.Required {
 			chatgpt_request_converter.RenewTokenForRequest(&translated_request, secret.PUID, chat_require.Arkose.DX, proxy_url)
 		}
-		response, err = chatgpt.POSTconversation(translated_request, &secret, deviceId, chat_require.Token, proxy_url)
+		response, err = chatgpt.POSTconversation(translated_request, &secret, deviceId, chat_require.Token, proofToken, proxy_url)
 		if err != nil {
 			c.JSON(500, gin.H{
 				"error": "error sending request",