Merge remote-tracking branch 'origin/upstream/main'

controller/billing.go

@@ -2,8 +2,9 @@ package controller
 
 import (
 	"github.com/gin-gonic/gin"
-	"one-api/common"
-	"one-api/model"
+	"github.com/songquanpeng/one-api/common/config"
+	"github.com/songquanpeng/one-api/model"
+	"github.com/songquanpeng/one-api/relay/channel/openai"
 )
 
 func GetSubscription(c *gin.Context) {
@@ -12,7 +13,7 @@ func GetSubscription(c *gin.Context) {
 	var err error
 	var token *model.Token
 	var expiredTime int64
-	if common.DisplayTokenStatEnabled {
+	if config.DisplayTokenStatEnabled {
 		tokenId := c.GetInt("token_id")
 		token, err = model.GetTokenById(tokenId)
 		expiredTime = token.ExpiredTime
@@ -27,19 +28,19 @@ func GetSubscription(c *gin.Context) {
 		expiredTime = 0
 	}
 	if err != nil {
-		openAIError := OpenAIError{
+		Error := openai.Error{
 			Message: err.Error(),
 			Type:    "upstream_error",
 		}
 		c.JSON(200, gin.H{
-			"error": openAIError,
+			"error": Error,
 		})
 		return
 	}
 	quota := remainQuota + usedQuota
 	amount := float64(quota)
-	if common.DisplayInCurrencyEnabled {
-		amount /= common.QuotaPerUnit
+	if config.DisplayInCurrencyEnabled {
+		amount /= config.QuotaPerUnit
 	}
 	if token != nil && token.UnlimitedQuota {
 		amount = 100000000
@@ -60,7 +61,7 @@ func GetUsage(c *gin.Context) {
 	var quota int
 	var err error
 	var token *model.Token
-	if common.DisplayTokenStatEnabled {
+	if config.DisplayTokenStatEnabled {
 		tokenId := c.GetInt("token_id")
 		token, err = model.GetTokenById(tokenId)
 		quota = token.UsedQuota
@@ -69,18 +70,18 @@ func GetUsage(c *gin.Context) {
 		quota, err = model.GetUserUsedQuota(userId)
 	}
 	if err != nil {
-		openAIError := OpenAIError{
+		Error := openai.Error{
 			Message: err.Error(),
 			Type:    "one_api_error",
 		}
 		c.JSON(200, gin.H{
-			"error": openAIError,
+			"error": Error,
 		})
 		return
 	}
 	amount := float64(quota)
-	if common.DisplayInCurrencyEnabled {
-		amount /= common.QuotaPerUnit
+	if config.DisplayInCurrencyEnabled {
+		amount /= config.QuotaPerUnit
 	}
 	usage := OpenAIUsageResponse{
 		Object:     "list",

controller/channel-billing.go

@@ -4,10 +4,13 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"github.com/songquanpeng/one-api/common"
+	"github.com/songquanpeng/one-api/common/config"
+	"github.com/songquanpeng/one-api/common/logger"
+	"github.com/songquanpeng/one-api/model"
+	"github.com/songquanpeng/one-api/relay/util"
 	"io"
 	"net/http"
-	"one-api/common"
-	"one-api/model"
 	"strconv"
 	"time"
 
@@ -92,7 +95,7 @@ func GetResponseBody(method, url string, channel *model.Channel, headers http.He
 	for k := range headers {
 		req.Header.Add(k, headers.Get(k))
 	}
-	res, err := httpClient.Do(req)
+	res, err := util.HTTPClient.Do(req)
 	if err != nil {
 		return nil, err
 	}
@@ -313,7 +316,7 @@ func updateAllChannelsBalance() error {
 				disableChannel(channel.Id, channel.Name, "余额不足")
 			}
 		}
-		time.Sleep(common.RequestInterval)
+		time.Sleep(config.RequestInterval)
 	}
 	return nil
 }
@@ -338,8 +341,8 @@ func UpdateAllChannelsBalance(c *gin.Context) {
 func AutomaticallyUpdateChannels(frequency int) {
 	for {
 		time.Sleep(time.Duration(frequency) * time.Minute)
-		common.SysLog("updating all channels")
+		logger.SysLog("updating all channels")
 		_ = updateAllChannelsBalance()
-		common.SysLog("channels update done")
+		logger.SysLog("channels update done")
 	}
 }

controller/channel-test.go

@@ -5,10 +5,14 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"github.com/songquanpeng/one-api/common"
+	"github.com/songquanpeng/one-api/common/config"
+	"github.com/songquanpeng/one-api/common/logger"
+	"github.com/songquanpeng/one-api/model"
+	"github.com/songquanpeng/one-api/relay/channel/openai"
+	"github.com/songquanpeng/one-api/relay/util"
 	"io"
 	"net/http"
-	"one-api/common"
-	"one-api/model"
 	"strconv"
 	"sync"
 	"time"
@@ -16,7 +20,7 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-func testChannel(channel *model.Channel, request ChatRequest) (err error, openaiErr *OpenAIError) {
+func testChannel(channel *model.Channel, request openai.ChatRequest) (err error, openaiErr *openai.Error) {
 	switch channel.Type {
 	case common.ChannelTypePaLM:
 		fallthrough
@@ -46,13 +50,13 @@ func testChannel(channel *model.Channel, request ChatRequest) (err error, openai
 	}
 	requestURL := common.ChannelBaseURLs[channel.Type]
 	if channel.Type == common.ChannelTypeAzure {
-		requestURL = getFullRequestURL(channel.GetBaseURL(), fmt.Sprintf("/openai/deployments/%s/chat/completions?api-version=2023-03-15-preview", request.Model), channel.Type)
+		requestURL = util.GetFullRequestURL(channel.GetBaseURL(), fmt.Sprintf("/openai/deployments/%s/chat/completions?api-version=2023-03-15-preview", request.Model), channel.Type)
 	} else {
 		if baseURL := channel.GetBaseURL(); len(baseURL) > 0 {
 			requestURL = baseURL
 		}
 
-		requestURL = getFullRequestURL(requestURL, "/v1/chat/completions", channel.Type)
+		requestURL = util.GetFullRequestURL(requestURL, "/v1/chat/completions", channel.Type)
 	}
 	jsonData, err := json.Marshal(request)
 	if err != nil {
@@ -68,12 +72,12 @@ func testChannel(channel *model.Channel, request ChatRequest) (err error, openai
 		req.Header.Set("Authorization", "Bearer "+channel.Key)
 	}
 	req.Header.Set("Content-Type", "application/json")
-	resp, err := httpClient.Do(req)
+	resp, err := util.HTTPClient.Do(req)
 	if err != nil {
 		return err, nil
 	}
 	defer resp.Body.Close()
-	var response TextResponse
+	var response openai.SlimTextResponse
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return err, nil
@@ -91,12 +95,12 @@ func testChannel(channel *model.Channel, request ChatRequest) (err error, openai
 	return nil, nil
 }
 
-func buildTestRequest() *ChatRequest {
-	testRequest := &ChatRequest{
+func buildTestRequest() *openai.ChatRequest {
+	testRequest := &openai.ChatRequest{
 		Model:     "", // this will be set later
 		MaxTokens: 1,
 	}
-	testMessage := Message{
+	testMessage := openai.Message{
 		Role:    "user",
 		Content: "hi",
 	}
@@ -148,12 +152,12 @@ var testAllChannelsLock sync.Mutex
 var testAllChannelsRunning bool = false
 
 func notifyRootUser(subject string, content string) {
-	if common.RootUserEmail == "" {
-		common.RootUserEmail = model.GetRootUserEmail()
+	if config.RootUserEmail == "" {
+		config.RootUserEmail = model.GetRootUserEmail()
 	}
-	err := common.SendEmail(subject, common.RootUserEmail, content)
+	err := common.SendEmail(subject, config.RootUserEmail, content)
 	if err != nil {
-		common.SysError(fmt.Sprintf("failed to send email: %s", err.Error()))
+		logger.SysError(fmt.Sprintf("failed to send email: %s", err.Error()))
 	}
 }
 
@@ -174,8 +178,8 @@ func enableChannel(channelId int, channelName string) {
 }
 
 func testAllChannels(notify bool) error {
-	if common.RootUserEmail == "" {
-		common.RootUserEmail = model.GetRootUserEmail()
+	if config.RootUserEmail == "" {
+		config.RootUserEmail = model.GetRootUserEmail()
 	}
 	testAllChannelsLock.Lock()
 	if testAllChannelsRunning {
@@ -189,7 +193,7 @@ func testAllChannels(notify bool) error {
 		return err
 	}
 	testRequest := buildTestRequest()
-	var disableThreshold = int64(common.ChannelDisableThreshold * 1000)
+	var disableThreshold = int64(config.ChannelDisableThreshold * 1000)
 	if disableThreshold == 0 {
 		disableThreshold = 10000000 // a impossible value
 	}
@@ -204,22 +208,22 @@ func testAllChannels(notify bool) error {
 				err = errors.New(fmt.Sprintf("响应时间 %.2fs 超过阈值 %.2fs", float64(milliseconds)/1000.0, float64(disableThreshold)/1000.0))
 				disableChannel(channel.Id, channel.Name, err.Error())
 			}
-			if isChannelEnabled && shouldDisableChannel(openaiErr, -1) {
+			if isChannelEnabled && util.ShouldDisableChannel(openaiErr, -1) {
 				disableChannel(channel.Id, channel.Name, err.Error())
 			}
-			if !isChannelEnabled && shouldEnableChannel(err, openaiErr) {
+			if !isChannelEnabled && util.ShouldEnableChannel(err, openaiErr) {
 				enableChannel(channel.Id, channel.Name)
 			}
 			channel.UpdateResponseTime(milliseconds)
-			time.Sleep(common.RequestInterval)
+			time.Sleep(config.RequestInterval)
 		}
 		testAllChannelsLock.Lock()
 		testAllChannelsRunning = false
 		testAllChannelsLock.Unlock()
 		if notify {
-			err := common.SendEmail("通道测试完成", common.RootUserEmail, "通道测试完成，如果没有收到禁用通知，说明所有通道都正常")
+			err := common.SendEmail("通道测试完成", config.RootUserEmail, "通道测试完成，如果没有收到禁用通知，说明所有通道都正常")
 			if err != nil {
-				common.SysError(fmt.Sprintf("failed to send email: %s", err.Error()))
+				logger.SysError(fmt.Sprintf("failed to send email: %s", err.Error()))
 			}
 		}
 	}()
@@ -245,8 +249,8 @@ func TestAllChannels(c *gin.Context) {
 func AutomaticallyTestChannels(frequency int) {
 	for {
 		time.Sleep(time.Duration(frequency) * time.Minute)
-		common.SysLog("testing all channels")
+		logger.SysLog("testing all channels")
 		_ = testAllChannels(false)
-		common.SysLog("channel test finished")
+		logger.SysLog("channel test finished")
 	}
 }

controller/channel.go

@@ -2,9 +2,10 @@ package controller
 
 import (
 	"github.com/gin-gonic/gin"
+	"github.com/songquanpeng/one-api/common/config"
+	"github.com/songquanpeng/one-api/common/helper"
+	"github.com/songquanpeng/one-api/model"
 	"net/http"
-	"one-api/common"
-	"one-api/model"
 	"strconv"
 	"strings"
 )
@@ -14,7 +15,7 @@ func GetAllChannels(c *gin.Context) {
 	if p < 0 {
 		p = 0
 	}
-	channels, err := model.GetAllChannels(p*common.ItemsPerPage, common.ItemsPerPage, false)
+	channels, err := model.GetAllChannels(p*config.ItemsPerPage, config.ItemsPerPage, false)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
@@ -83,7 +84,7 @@ func AddChannel(c *gin.Context) {
 		})
 		return
 	}
-	channel.CreatedTime = common.GetTimestamp()
+	channel.CreatedTime = helper.GetTimestamp()
 	keys := strings.Split(channel.Key, "\n")
 	channels := make([]model.Channel, 0, len(keys))
 	for _, key := range keys {

controller/github.go

@@ -7,9 +7,12 @@ import (
 	"fmt"
 	"github.com/gin-contrib/sessions"
 	"github.com/gin-gonic/gin"
+	"github.com/songquanpeng/one-api/common"
+	"github.com/songquanpeng/one-api/common/config"
+	"github.com/songquanpeng/one-api/common/helper"
+	"github.com/songquanpeng/one-api/common/logger"
+	"github.com/songquanpeng/one-api/model"
 	"net/http"
-	"one-api/common"
-	"one-api/model"
 	"strconv"
 	"time"
 )
@@ -30,7 +33,7 @@ func getGitHubUserInfoByCode(code string) (*GitHubUser, error) {
 	if code == "" {
 		return nil, errors.New("无效的参数")
 	}
-	values := map[string]string{"client_id": common.GitHubClientId, "client_secret": common.GitHubClientSecret, "code": code}
+	values := map[string]string{"client_id": config.GitHubClientId, "client_secret": config.GitHubClientSecret, "code": code}
 	jsonData, err := json.Marshal(values)
 	if err != nil {
 		return nil, err
@@ -46,7 +49,7 @@ func getGitHubUserInfoByCode(code string) (*GitHubUser, error) {
 	}
 	res, err := client.Do(req)
 	if err != nil {
-		common.SysLog(err.Error())
+		logger.SysLog(err.Error())
 		return nil, errors.New("无法连接至 GitHub 服务器，请稍后重试！")
 	}
 	defer res.Body.Close()
@@ -62,7 +65,7 @@ func getGitHubUserInfoByCode(code string) (*GitHubUser, error) {
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", oAuthResponse.AccessToken))
 	res2, err := client.Do(req)
 	if err != nil {
-		common.SysLog(err.Error())
+		logger.SysLog(err.Error())
 		return nil, errors.New("无法连接至 GitHub 服务器，请稍后重试！")
 	}
 	defer res2.Body.Close()
@@ -93,7 +96,7 @@ func GitHubOAuth(c *gin.Context) {
 		return
 	}
 
-	if !common.GitHubOAuthEnabled {
+	if !config.GitHubOAuthEnabled {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
 			"message": "管理员未开启通过 GitHub 登录以及注册",
@@ -122,7 +125,7 @@ func GitHubOAuth(c *gin.Context) {
 			return
 		}
 	} else {
-		if common.RegisterEnabled {
+		if config.RegisterEnabled {
 			user.Username = "github_" + strconv.Itoa(model.GetMaxUserId()+1)
 			if githubUser.Name != "" {
 				user.DisplayName = githubUser.Name
@@ -160,7 +163,7 @@ func GitHubOAuth(c *gin.Context) {
 }
 
 func GitHubBind(c *gin.Context) {
-	if !common.GitHubOAuthEnabled {
+	if !config.GitHubOAuthEnabled {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
 			"message": "管理员未开启通过 GitHub 登录以及注册",
@@ -216,7 +219,7 @@ func GitHubBind(c *gin.Context) {
 
 func GenerateOAuthCode(c *gin.Context) {
 	session := sessions.Default(c)
-	state := common.GetRandomString(12)
+	state := helper.GetRandomString(12)
 	session.Set("oauth_state", state)
 	err := session.Save()
 	if err != nil {

controller/group.go

@@ -2,8 +2,8 @@ package controller
 
 import (
 	"github.com/gin-gonic/gin"
+	"github.com/songquanpeng/one-api/common"
 	"net/http"
-	"one-api/common"
 )
 
 func GetGroups(c *gin.Context) {

controller/log.go

@@ -2,9 +2,9 @@ package controller
 
 import (
 	"github.com/gin-gonic/gin"
+	"github.com/songquanpeng/one-api/common/config"
+	"github.com/songquanpeng/one-api/model"
 	"net/http"
-	"one-api/common"
-	"one-api/model"
 	"strconv"
 )
 
@@ -20,7 +20,7 @@ func GetAllLogs(c *gin.Context) {
 	tokenName := c.Query("token_name")
 	modelName := c.Query("model_name")
 	channel, _ := strconv.Atoi(c.Query("channel"))
-	logs, err := model.GetAllLogs(logType, startTimestamp, endTimestamp, modelName, username, tokenName, p*common.ItemsPerPage, common.ItemsPerPage, channel)
+	logs, err := model.GetAllLogs(logType, startTimestamp, endTimestamp, modelName, username, tokenName, p*config.ItemsPerPage, config.ItemsPerPage, channel)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
@@ -47,7 +47,7 @@ func GetUserLogs(c *gin.Context) {
 	endTimestamp, _ := strconv.ParseInt(c.Query("end_timestamp"), 10, 64)
 	tokenName := c.Query("token_name")
 	modelName := c.Query("model_name")
-	logs, err := model.GetUserLogs(userId, logType, startTimestamp, endTimestamp, modelName, tokenName, p*common.ItemsPerPage, common.ItemsPerPage)
+	logs, err := model.GetUserLogs(userId, logType, startTimestamp, endTimestamp, modelName, tokenName, p*config.ItemsPerPage, config.ItemsPerPage)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,

controller/misc.go

@@ -3,9 +3,10 @@ package controller
 import (
 	"encoding/json"
 	"fmt"
+	"github.com/songquanpeng/one-api/common"
+	"github.com/songquanpeng/one-api/common/config"
+	"github.com/songquanpeng/one-api/model"
 	"net/http"
-	"one-api/common"
-	"one-api/model"
 	"strings"
 
 	"github.com/gin-gonic/gin"
@@ -18,55 +19,55 @@ func GetStatus(c *gin.Context) {
 		"data": gin.H{
 			"version":             common.Version,
 			"start_time":          common.StartTime,
-			"email_verification":  common.EmailVerificationEnabled,
-			"github_oauth":        common.GitHubOAuthEnabled,
-			"github_client_id":    common.GitHubClientId,
-			"system_name":         common.SystemName,
-			"logo":                common.Logo,
-			"footer_html":         common.Footer,
-			"wechat_qrcode":       common.WeChatAccountQRCodeImageURL,
-			"wechat_login":        common.WeChatAuthEnabled,
-			"server_address":      common.ServerAddress,
-			"turnstile_check":     common.TurnstileCheckEnabled,
-			"turnstile_site_key":  common.TurnstileSiteKey,
-			"top_up_link":         common.TopUpLink,
-			"chat_link":           common.ChatLink,
-			"quota_per_unit":      common.QuotaPerUnit,
-			"display_in_currency": common.DisplayInCurrencyEnabled,
+			"email_verification":  config.EmailVerificationEnabled,
+			"github_oauth":        config.GitHubOAuthEnabled,
+			"github_client_id":    config.GitHubClientId,
+			"system_name":         config.SystemName,
+			"logo":                config.Logo,
+			"footer_html":         config.Footer,
+			"wechat_qrcode":       config.WeChatAccountQRCodeImageURL,
+			"wechat_login":        config.WeChatAuthEnabled,
+			"server_address":      config.ServerAddress,
+			"turnstile_check":     config.TurnstileCheckEnabled,
+			"turnstile_site_key":  config.TurnstileSiteKey,
+			"top_up_link":         config.TopUpLink,
+			"chat_link":           config.ChatLink,
+			"quota_per_unit":      config.QuotaPerUnit,
+			"display_in_currency": config.DisplayInCurrencyEnabled,
 		},
 	})
 	return
 }
 
 func GetNotice(c *gin.Context) {
-	common.OptionMapRWMutex.RLock()
-	defer common.OptionMapRWMutex.RUnlock()
+	config.OptionMapRWMutex.RLock()
+	defer config.OptionMapRWMutex.RUnlock()
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
 		"message": "",
-		"data":    common.OptionMap["Notice"],
+		"data":    config.OptionMap["Notice"],
 	})
 	return
 }
 
 func GetAbout(c *gin.Context) {
-	common.OptionMapRWMutex.RLock()
-	defer common.OptionMapRWMutex.RUnlock()
+	config.OptionMapRWMutex.RLock()
+	defer config.OptionMapRWMutex.RUnlock()
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
 		"message": "",
-		"data":    common.OptionMap["About"],
+		"data":    config.OptionMap["About"],
 	})
 	return
 }
 
 func GetHomePageContent(c *gin.Context) {
-	common.OptionMapRWMutex.RLock()
-	defer common.OptionMapRWMutex.RUnlock()
+	config.OptionMapRWMutex.RLock()
+	defer config.OptionMapRWMutex.RUnlock()
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
 		"message": "",
-		"data":    common.OptionMap["HomePageContent"],
+		"data":    config.OptionMap["HomePageContent"],
 	})
 	return
 }
@@ -80,9 +81,9 @@ func SendEmailVerification(c *gin.Context) {
 		})
 		return
 	}
-	if common.EmailDomainRestrictionEnabled {
+	if config.EmailDomainRestrictionEnabled {
 		allowed := false
-		for _, domain := range common.EmailDomainWhitelist {
+		for _, domain := range config.EmailDomainWhitelist {
 			if strings.HasSuffix(email, "@"+domain) {
 				allowed = true
 				break
@@ -105,10 +106,10 @@ func SendEmailVerification(c *gin.Context) {
 	}
 	code := common.GenerateVerificationCode(6)
 	common.RegisterVerificationCodeWithKey(email, code, common.EmailVerificationPurpose)
-	subject := fmt.Sprintf("%s邮箱验证邮件", common.SystemName)
+	subject := fmt.Sprintf("%s邮箱验证邮件", config.SystemName)
 	content := fmt.Sprintf("<p>您好，你正在进行%s邮箱验证。</p>"+
 		"<p>您的验证码为: <strong>%s</strong></p>"+
-		"<p>验证码 %d 分钟内有效，如果不是本人操作，请忽略。</p>", common.SystemName, code, common.VerificationValidMinutes)
+		"<p>验证码 %d 分钟内有效，如果不是本人操作，请忽略。</p>", config.SystemName, code, common.VerificationValidMinutes)
 	err := common.SendEmail(subject, email, content)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
@@ -142,12 +143,12 @@ func SendPasswordResetEmail(c *gin.Context) {
 	}
 	code := common.GenerateVerificationCode(0)
 	common.RegisterVerificationCodeWithKey(email, code, common.PasswordResetPurpose)
-	link := fmt.Sprintf("%s/user/reset?email=%s&token=%s", common.ServerAddress, email, code)
-	subject := fmt.Sprintf("%s密码重置", common.SystemName)
+	link := fmt.Sprintf("%s/user/reset?email=%s&token=%s", config.ServerAddress, email, code)
+	subject := fmt.Sprintf("%s密码重置", config.SystemName)
 	content := fmt.Sprintf("<p>您好，你正在进行%s密码重置。</p>"+
 		"<p>点击 <a href='%s'>此处</a> 进行密码重置。</p>"+
 		"<p>如果链接无法点击，请尝试点击下面的链接或将其复制到浏览器中打开：<br> %s </p>"+
-		"<p>重置链接 %d 分钟内有效，如果不是本人操作，请忽略。</p>", common.SystemName, link, link, common.VerificationValidMinutes)
+		"<p>重置链接 %d 分钟内有效，如果不是本人操作，请忽略。</p>", config.SystemName, link, link, common.VerificationValidMinutes)
 	err := common.SendEmail(subject, email, content)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{

controller/model.go

@@ -2,8 +2,8 @@ package controller
 
 import (
 	"fmt"
-
 	"github.com/gin-gonic/gin"
+	"github.com/songquanpeng/one-api/relay/channel/openai"
 )
 
 // https://platform.openai.com/docs/api-reference/models/list
@@ -171,6 +171,15 @@ func init() {
 			Root:       "gpt-3.5-turbo-1106",
 			Parent:     nil,
 		},
+		{
+			Id:         "gpt-3.5-turbo-0125",
+			Object:     "model",
+			Created:    1706232090,
+			OwnedBy:    "openai",
+			Permission: permission,
+			Root:       "gpt-3.5-turbo-0125",
+			Parent:     nil,
+		},
 		{
 			Id:         "gpt-3.5-turbo-instruct",
 			Object:     "model",
@@ -243,6 +252,24 @@ func init() {
 			Root:       "gpt-4-1106-preview",
 			Parent:     nil,
 		},
+		{
+			Id:         "gpt-4-0125-preview",
+			Object:     "model",
+			Created:    1706232090,
+			OwnedBy:    "openai",
+			Permission: permission,
+			Root:       "gpt-4-0125-preview",
+			Parent:     nil,
+		},
+		{
+			Id:         "gpt-4-turbo-preview",
+			Object:     "model",
+			Created:    1706232090,
+			OwnedBy:    "openai",
+			Permission: permission,
+			Root:       "gpt-4-turbo-preview",
+			Parent:     nil,
+		},
 		{
 			Id:         "gpt-4-vision-preview",
 			Object:     "model",
@@ -261,6 +288,24 @@ func init() {
 			Root:       "text-embedding-ada-002",
 			Parent:     nil,
 		},
+		{
+			Id:         "text-embedding-3-small",
+			Object:     "model",
+			Created:    1706232090,
+			OwnedBy:    "openai",
+			Permission: permission,
+			Root:       "text-embedding-3-small",
+			Parent:     nil,
+		},
+		{
+			Id:         "text-embedding-3-large",
+			Object:     "model",
+			Created:    1706232090,
+			OwnedBy:    "openai",
+			Permission: permission,
+			Root:       "text-embedding-3-large",
+			Parent:     nil,
+		},
 		{
 			Id:         "text-davinci-003",
 			Object:     "model",
@@ -613,14 +658,14 @@ func RetrieveModel(c *gin.Context) {
 	if model, ok := openAIModelsMap[modelId]; ok {
 		c.JSON(200, model)
 	} else {
-		openAIError := OpenAIError{
+		Error := openai.Error{
 			Message: fmt.Sprintf("The model '%s' does not exist", modelId),
 			Type:    "invalid_request_error",
 			Param:   "model",
 			Code:    "model_not_found",
 		}
 		c.JSON(200, gin.H{
-			"error": openAIError,
+			"error": Error,
 		})
 	}
 }

controller/option.go

@@ -2,9 +2,10 @@ package controller
 
 import (
 	"encoding/json"
+	"github.com/songquanpeng/one-api/common/config"
+	"github.com/songquanpeng/one-api/common/helper"
+	"github.com/songquanpeng/one-api/model"
 	"net/http"
-	"one-api/common"
-	"one-api/model"
 	"strings"
 
 	"github.com/gin-gonic/gin"
@@ -12,17 +13,17 @@ import (
 
 func GetOptions(c *gin.Context) {
 	var options []*model.Option
-	common.OptionMapRWMutex.Lock()
-	for k, v := range common.OptionMap {
+	config.OptionMapRWMutex.Lock()
+	for k, v := range config.OptionMap {
 		if strings.HasSuffix(k, "Token") || strings.HasSuffix(k, "Secret") {
 			continue
 		}
 		options = append(options, &model.Option{
 			Key:   k,
-			Value: common.Interface2String(v),
+			Value: helper.Interface2String(v),
 		})
 	}
-	common.OptionMapRWMutex.Unlock()
+	config.OptionMapRWMutex.Unlock()
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
 		"message": "",
@@ -43,7 +44,7 @@ func UpdateOption(c *gin.Context) {
 	}
 	switch option.Key {
 	case "Theme":
-		if !common.ValidThemes[option.Value] {
+		if !config.ValidThemes[option.Value] {
 			c.JSON(http.StatusOK, gin.H{
 				"success": false,
 				"message": "无效的主题",
@@ -51,7 +52,7 @@ func UpdateOption(c *gin.Context) {
 			return
 		}
 	case "GitHubOAuthEnabled":
-		if option.Value == "true" && common.GitHubClientId == "" {
+		if option.Value == "true" && config.GitHubClientId == "" {
 			c.JSON(http.StatusOK, gin.H{
 				"success": false,
 				"message": "无法启用 GitHub OAuth，请先填入 GitHub Client Id 以及 GitHub Client Secret！",
@@ -59,7 +60,7 @@ func UpdateOption(c *gin.Context) {
 			return
 		}
 	case "EmailDomainRestrictionEnabled":
-		if option.Value == "true" && len(common.EmailDomainWhitelist) == 0 {
+		if option.Value == "true" && len(config.EmailDomainWhitelist) == 0 {
 			c.JSON(http.StatusOK, gin.H{
 				"success": false,
 				"message": "无法启用邮箱域名限制，请先填入限制的邮箱域名！",
@@ -67,7 +68,7 @@ func UpdateOption(c *gin.Context) {
 			return
 		}
 	case "WeChatAuthEnabled":
-		if option.Value == "true" && common.WeChatServerAddress == "" {
+		if option.Value == "true" && config.WeChatServerAddress == "" {
 			c.JSON(http.StatusOK, gin.H{
 				"success": false,
 				"message": "无法启用微信登录，请先填入微信登录相关配置信息！",
@@ -75,7 +76,7 @@ func UpdateOption(c *gin.Context) {
 			return
 		}
 	case "TurnstileCheckEnabled":
-		if option.Value == "true" && common.TurnstileSiteKey == "" {
+		if option.Value == "true" && config.TurnstileSiteKey == "" {
 			c.JSON(http.StatusOK, gin.H{
 				"success": false,
 				"message": "无法启用 Turnstile 校验，请先填入 Turnstile 校验相关配置信息！",

controller/redemption.go

@@ -2,9 +2,10 @@ package controller
 
 import (
 	"github.com/gin-gonic/gin"
+	"github.com/songquanpeng/one-api/common/config"
+	"github.com/songquanpeng/one-api/common/helper"
+	"github.com/songquanpeng/one-api/model"
 	"net/http"
-	"one-api/common"
-	"one-api/model"
 	"strconv"
 )
 
@@ -13,7 +14,7 @@ func GetAllRedemptions(c *gin.Context) {
 	if p < 0 {
 		p = 0
 	}
-	redemptions, err := model.GetAllRedemptions(p*common.ItemsPerPage, common.ItemsPerPage)
+	redemptions, err := model.GetAllRedemptions(p*config.ItemsPerPage, config.ItemsPerPage)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
@@ -105,12 +106,12 @@ func AddRedemption(c *gin.Context) {
 	}
 	var keys []string
 	for i := 0; i < redemption.Count; i++ {
-		key := common.GetUUID()
+		key := helper.GetUUID()
 		cleanRedemption := model.Redemption{
 			UserId:      c.GetInt("id"),
 			Name:        redemption.Name,
 			Key:         key,
-			CreatedTime: common.GetTimestamp(),
+			CreatedTime: helper.GetTimestamp(),
 			Quota:       redemption.Quota,
 		}
 		err = cleanRedemption.Insert()

controller/relay-aiproxy.go

@@ -1,222 +0,0 @@
-package controller
-
-import (
-	"bufio"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"one-api/common"
-	"strconv"
-	"strings"
-
-	"github.com/gin-gonic/gin"
-)
-
-// https://docs.aiproxy.io/dev/library#使用已经定制好的知识库进行对话问答
-
-type AIProxyLibraryRequest struct {
-	Model     string `json:"model"`
-	Query     string `json:"query"`
-	LibraryId string `json:"libraryId"`
-	Stream    bool   `json:"stream"`
-}
-
-type AIProxyLibraryError struct {
-	ErrCode int    `json:"errCode"`
-	Message string `json:"message"`
-}
-
-type AIProxyLibraryDocument struct {
-	Title string `json:"title"`
-	URL   string `json:"url"`
-}
-
-type AIProxyLibraryResponse struct {
-	Success   bool                     `json:"success"`
-	Answer    string                   `json:"answer"`
-	Documents []AIProxyLibraryDocument `json:"documents"`
-	AIProxyLibraryError
-}
-
-type AIProxyLibraryStreamResponse struct {
-	Content   string                   `json:"content"`
-	Finish    bool                     `json:"finish"`
-	Model     string                   `json:"model"`
-	Documents []AIProxyLibraryDocument `json:"documents"`
-}
-
-func requestOpenAI2AIProxyLibrary(request GeneralOpenAIRequest) *AIProxyLibraryRequest {
-	query := ""
-	if len(request.Messages) != 0 {
-		query = request.Messages[len(request.Messages)-1].StringContent()
-	}
-
-	return &AIProxyLibraryRequest{
-		Model:  request.Model,
-		Stream: request.Stream,
-		Query:  query,
-	}
-}
-
-func aiProxyDocuments2Markdown(documents []AIProxyLibraryDocument) string {
-	if len(documents) == 0 {
-		return ""
-	}
-	content := "\n\n参考文档：\n"
-	for i, document := range documents {
-		content += fmt.Sprintf("%d. [%s](%s)\n", i+1, document.Title, document.URL)
-	}
-	return content
-}
-
-func responseAIProxyLibrary2OpenAI(response *AIProxyLibraryResponse) *OpenAITextResponse {
-	content := response.Answer + aiProxyDocuments2Markdown(response.Documents)
-	choice := OpenAITextResponseChoice{
-		Index: 0,
-		Message: Message{
-			Role:    "assistant",
-			Content: content,
-		},
-		FinishReason: "stop",
-	}
-	fullTextResponse := OpenAITextResponse{
-		Id:      common.GetUUID(),
-		Object:  "chat.completion",
-		Created: common.GetTimestamp(),
-		Choices: []OpenAITextResponseChoice{choice},
-	}
-	return &fullTextResponse
-}
-
-func documentsAIProxyLibrary(documents []AIProxyLibraryDocument) *ChatCompletionsStreamResponse {
-	var choice ChatCompletionsStreamResponseChoice
-	choice.Delta.Content = aiProxyDocuments2Markdown(documents)
-	choice.FinishReason = &stopFinishReason
-	return &ChatCompletionsStreamResponse{
-		Id:      common.GetUUID(),
-		Object:  "chat.completion.chunk",
-		Created: common.GetTimestamp(),
-		Model:   "",
-		Choices: []ChatCompletionsStreamResponseChoice{choice},
-	}
-}
-
-func streamResponseAIProxyLibrary2OpenAI(response *AIProxyLibraryStreamResponse) *ChatCompletionsStreamResponse {
-	var choice ChatCompletionsStreamResponseChoice
-	choice.Delta.Content = response.Content
-	return &ChatCompletionsStreamResponse{
-		Id:      common.GetUUID(),
-		Object:  "chat.completion.chunk",
-		Created: common.GetTimestamp(),
-		Model:   response.Model,
-		Choices: []ChatCompletionsStreamResponseChoice{choice},
-	}
-}
-
-func aiProxyLibraryStreamHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, *Usage) {
-	var usage Usage
-	scanner := bufio.NewScanner(resp.Body)
-	scanner.Split(func(data []byte, atEOF bool) (advance int, token []byte, err error) {
-		if atEOF && len(data) == 0 {
-			return 0, nil, nil
-		}
-		if i := strings.Index(string(data), "\n"); i >= 0 {
-			return i + 1, data[0:i], nil
-		}
-		if atEOF {
-			return len(data), data, nil
-		}
-		return 0, nil, nil
-	})
-	dataChan := make(chan string)
-	stopChan := make(chan bool)
-	go func() {
-		for scanner.Scan() {
-			data := scanner.Text()
-			if len(data) < 5 { // ignore blank line or wrong format
-				continue
-			}
-			if data[:5] != "data:" {
-				continue
-			}
-			data = data[5:]
-			dataChan <- data
-		}
-		stopChan <- true
-	}()
-	setEventStreamHeaders(c)
-	var documents []AIProxyLibraryDocument
-	c.Stream(func(w io.Writer) bool {
-		select {
-		case data := <-dataChan:
-			var AIProxyLibraryResponse AIProxyLibraryStreamResponse
-			err := json.Unmarshal([]byte(data), &AIProxyLibraryResponse)
-			if err != nil {
-				common.SysError("error unmarshalling stream response: " + err.Error())
-				return true
-			}
-			if len(AIProxyLibraryResponse.Documents) != 0 {
-				documents = AIProxyLibraryResponse.Documents
-			}
-			response := streamResponseAIProxyLibrary2OpenAI(&AIProxyLibraryResponse)
-			jsonResponse, err := json.Marshal(response)
-			if err != nil {
-				common.SysError("error marshalling stream response: " + err.Error())
-				return true
-			}
-			c.Render(-1, common.CustomEvent{Data: "data: " + string(jsonResponse)})
-			return true
-		case <-stopChan:
-			response := documentsAIProxyLibrary(documents)
-			jsonResponse, err := json.Marshal(response)
-			if err != nil {
-				common.SysError("error marshalling stream response: " + err.Error())
-				return true
-			}
-			c.Render(-1, common.CustomEvent{Data: "data: " + string(jsonResponse)})
-			c.Render(-1, common.CustomEvent{Data: "data: [DONE]"})
-			return false
-		}
-	})
-	err := resp.Body.Close()
-	if err != nil {
-		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
-	}
-	return nil, &usage
-}
-
-func aiProxyLibraryHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, *Usage) {
-	var AIProxyLibraryResponse AIProxyLibraryResponse
-	responseBody, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
-	}
-	err = resp.Body.Close()
-	if err != nil {
-		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
-	}
-	err = json.Unmarshal(responseBody, &AIProxyLibraryResponse)
-	if err != nil {
-		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
-	}
-	if AIProxyLibraryResponse.ErrCode != 0 {
-		return &OpenAIErrorWithStatusCode{
-			OpenAIError: OpenAIError{
-				Message: AIProxyLibraryResponse.Message,
-				Type:    strconv.Itoa(AIProxyLibraryResponse.ErrCode),
-				Code:    AIProxyLibraryResponse.ErrCode,
-			},
-			StatusCode: resp.StatusCode,
-		}, nil
-	}
-	fullTextResponse := responseAIProxyLibrary2OpenAI(&AIProxyLibraryResponse)
-	jsonResponse, err := json.Marshal(fullTextResponse)
-	if err != nil {
-		return errorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
-	}
-	c.Writer.Header().Set("Content-Type", "application/json")
-	c.Writer.WriteHeader(resp.StatusCode)
-	_, err = c.Writer.Write(jsonResponse)
-	return nil, &fullTextResponse.Usage
-}

controller/relay-ali.go

@@ -1,329 +0,0 @@
-package controller
-
-// import (
-// 	"bufio"
-// 	"encoding/json"
-// 	"github.com/gin-gonic/gin"
-// 	"io"
-// 	"net/http"
-// 	"one-api/common"
-// 	"strings"
-// )
-
-// // https://help.aliyun.com/document_detail/613695.html?spm=a2c4g.2399480.0.0.1adb778fAdzP9w#341800c0f8w0r
-
-// type AliMessage struct {
-// 	Content string `json:"content"`
-// 	Role    string `json:"role"`
-// }
-
-// type AliInput struct {
-// 	//Prompt   string       `json:"prompt"`
-// 	Messages []AliMessage `json:"messages"`
-// }
-
-// type AliParameters struct {
-// 	TopP         float64 `json:"top_p,omitempty"`
-// 	TopK         int     `json:"top_k,omitempty"`
-// 	Seed         uint64  `json:"seed,omitempty"`
-// 	EnableSearch bool    `json:"enable_search,omitempty"`
-// }
-
-// type AliChatRequest struct {
-// 	Model      string        `json:"model"`
-// 	Input      AliInput      `json:"input"`
-// 	Parameters AliParameters `json:"parameters,omitempty"`
-// }
-
-// type AliEmbeddingRequest struct {
-// 	Model string `json:"model"`
-// 	Input struct {
-// 		Texts []string `json:"texts"`
-// 	} `json:"input"`
-// 	Parameters *struct {
-// 		TextType string `json:"text_type,omitempty"`
-// 	} `json:"parameters,omitempty"`
-// }
-
-// type AliEmbedding struct {
-// 	Embedding []float64 `json:"embedding"`
-// 	TextIndex int       `json:"text_index"`
-// }
-
-// type AliEmbeddingResponse struct {
-// 	Output struct {
-// 		Embeddings []AliEmbedding `json:"embeddings"`
-// 	} `json:"output"`
-// 	Usage AliUsage `json:"usage"`
-// 	AliError
-// }
-
-// type AliError struct {
-// 	Code      string `json:"code"`
-// 	Message   string `json:"message"`
-// 	RequestId string `json:"request_id"`
-// }
-
-// type AliUsage struct {
-// 	InputTokens  int `json:"input_tokens"`
-// 	OutputTokens int `json:"output_tokens"`
-// 	TotalTokens  int `json:"total_tokens"`
-// }
-
-// type AliOutput struct {
-// 	Text         string `json:"text"`
-// 	FinishReason string `json:"finish_reason"`
-// }
-
-// type AliChatResponse struct {
-// 	Output AliOutput `json:"output"`
-// 	Usage  AliUsage  `json:"usage"`
-// 	AliError
-// }
-
-// func requestOpenAI2Ali(request GeneralOpenAIRequest) *AliChatRequest {
-// 	messages := make([]AliMessage, 0, len(request.Messages))
-// 	prompt := ""
-// 	for i := 0; i < len(request.Messages); i++ {
-// 		message := request.Messages[i]
-// 		if message.Role == "system" {
-// 			messages = append(messages, AliMessage{
-// 				User: message.Content,
-// 				Bot:  "Okay",
-// 			})
-// 			continue
-// 		} else {
-// 			if i == len(request.Messages)-1 {
-// 				prompt = message.Content
-// 				break
-// 			}
-// 			messages = append(messages, AliMessage{
-// 				User: message.Content,
-// 				Bot:  request.Messages[i+1].Content,
-// 			})
-// 			i++
-// 		}
-// 	}
-// 	return &AliChatRequest{
-// 		Model: request.Model,
-// 		Input: AliInput{
-// 			Prompt:  prompt,
-// 			History: messages,
-// 		},
-// 		//Parameters: AliParameters{  // ChatGPT's parameters are not compatible with Ali's
-// 		//	TopP: request.TopP,
-// 		//	TopK: 50,
-// 		//	//Seed:         0,
-// 		//	//EnableSearch: false,
-// 		//},
-// 	}
-// }
-
-// func embeddingRequestOpenAI2Ali(request GeneralOpenAIRequest) *AliEmbeddingRequest {
-// 	return &AliEmbeddingRequest{
-// 		Model: "text-embedding-v1",
-// 		Input: struct {
-// 			Texts []string `json:"texts"`
-// 		}{
-// 			Texts: request.ParseInput(),
-// 		},
-// 	}
-// }
-
-// func aliEmbeddingHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, *Usage) {
-// 	var aliResponse AliEmbeddingResponse
-// 	err := json.NewDecoder(resp.Body).Decode(&aliResponse)
-// 	if err != nil {
-// 		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-
-// 	err = resp.Body.Close()
-// 	if err != nil {
-// 		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-
-// 	if aliResponse.Code != "" {
-// 		return &OpenAIErrorWithStatusCode{
-// 			OpenAIError: OpenAIError{
-// 				Message: aliResponse.Message,
-// 				Type:    aliResponse.Code,
-// 				Param:   aliResponse.RequestId,
-// 				Code:    aliResponse.Code,
-// 			},
-// 			StatusCode: resp.StatusCode,
-// 		}, nil
-// 	}
-
-// 	fullTextResponse := embeddingResponseAli2OpenAI(&aliResponse)
-// 	jsonResponse, err := json.Marshal(fullTextResponse)
-// 	if err != nil {
-// 		return errorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	c.Writer.Header().Set("Content-Type", "application/json")
-// 	c.Writer.WriteHeader(resp.StatusCode)
-// 	_, err = c.Writer.Write(jsonResponse)
-// 	return nil, &fullTextResponse.Usage
-// }
-
-// func embeddingResponseAli2OpenAI(response *AliEmbeddingResponse) *OpenAIEmbeddingResponse {
-// 	openAIEmbeddingResponse := OpenAIEmbeddingResponse{
-// 		Object: "list",
-// 		Data:   make([]OpenAIEmbeddingResponseItem, 0, len(response.Output.Embeddings)),
-// 		Model:  "text-embedding-v1",
-// 		Usage:  Usage{TotalTokens: response.Usage.TotalTokens},
-// 	}
-
-// 	for _, item := range response.Output.Embeddings {
-// 		openAIEmbeddingResponse.Data = append(openAIEmbeddingResponse.Data, OpenAIEmbeddingResponseItem{
-// 			Object:    `embedding`,
-// 			Index:     item.TextIndex,
-// 			Embedding: item.Embedding,
-// 		})
-// 	}
-// 	return &openAIEmbeddingResponse
-// }
-
-// func responseAli2OpenAI(response *AliChatResponse) *OpenAITextResponse {
-// 	choice := OpenAITextResponseChoice{
-// 		Index: 0,
-// 		Message: Message{
-// 			Role:    "assistant",
-// 			Content: response.Output.Text,
-// 		},
-// 		FinishReason: response.Output.FinishReason,
-// 	}
-// 	fullTextResponse := OpenAITextResponse{
-// 		Id:      response.RequestId,
-// 		Object:  "chat.completion",
-// 		Created: common.GetTimestamp(),
-// 		Choices: []OpenAITextResponseChoice{choice},
-// 		Usage: Usage{
-// 			PromptTokens:     response.Usage.InputTokens,
-// 			CompletionTokens: response.Usage.OutputTokens,
-// 			TotalTokens:      response.Usage.InputTokens + response.Usage.OutputTokens,
-// 		},
-// 	}
-// 	return &fullTextResponse
-// }
-
-// func streamResponseAli2OpenAI(aliResponse *AliChatResponse) *ChatCompletionsStreamResponse {
-// 	var choice ChatCompletionsStreamResponseChoice
-// 	choice.Delta.Content = aliResponse.Output.Text
-// 	if aliResponse.Output.FinishReason != "null" {
-// 		finishReason := aliResponse.Output.FinishReason
-// 		choice.FinishReason = &finishReason
-// 	}
-// 	response := ChatCompletionsStreamResponse{
-// 		Id:      aliResponse.RequestId,
-// 		Object:  "chat.completion.chunk",
-// 		Created: common.GetTimestamp(),
-// 		Model:   "ernie-bot",
-// 		Choices: []ChatCompletionsStreamResponseChoice{choice},
-// 	}
-// 	return &response
-// }
-
-// func aliStreamHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, *Usage) {
-// 	var usage Usage
-// 	scanner := bufio.NewScanner(resp.Body)
-// 	scanner.Split(func(data []byte, atEOF bool) (advance int, token []byte, err error) {
-// 		if atEOF && len(data) == 0 {
-// 			return 0, nil, nil
-// 		}
-// 		if i := strings.Index(string(data), "\n"); i >= 0 {
-// 			return i + 1, data[0:i], nil
-// 		}
-// 		if atEOF {
-// 			return len(data), data, nil
-// 		}
-// 		return 0, nil, nil
-// 	})
-// 	dataChan := make(chan string)
-// 	stopChan := make(chan bool)
-// 	go func() {
-// 		for scanner.Scan() {
-// 			data := scanner.Text()
-// 			if len(data) < 5 { // ignore blank line or wrong format
-// 				continue
-// 			}
-// 			if data[:5] != "data:" {
-// 				continue
-// 			}
-// 			data = data[5:]
-// 			dataChan <- data
-// 		}
-// 		stopChan <- true
-// 	}()
-// 	setEventStreamHeaders(c)
-// 	lastResponseText := ""
-// 	c.Stream(func(w io.Writer) bool {
-// 		select {
-// 		case data := <-dataChan:
-// 			var aliResponse AliChatResponse
-// 			err := json.Unmarshal([]byte(data), &aliResponse)
-// 			if err != nil {
-// 				common.SysError("error unmarshalling stream response: " + err.Error())
-// 				return true
-// 			}
-// 			if aliResponse.Usage.OutputTokens != 0 {
-// 				usage.PromptTokens = aliResponse.Usage.InputTokens
-// 				usage.CompletionTokens = aliResponse.Usage.OutputTokens
-// 				usage.TotalTokens = aliResponse.Usage.InputTokens + aliResponse.Usage.OutputTokens
-// 			}
-// 			response := streamResponseAli2OpenAI(&aliResponse)
-// 			response.Choices[0].Delta.Content = strings.TrimPrefix(response.Choices[0].Delta.Content, lastResponseText)
-// 			lastResponseText = aliResponse.Output.Text
-// 			jsonResponse, err := json.Marshal(response)
-// 			if err != nil {
-// 				common.SysError("error marshalling stream response: " + err.Error())
-// 				return true
-// 			}
-// 			c.Render(-1, common.CustomEvent{Data: "data: " + string(jsonResponse)})
-// 			return true
-// 		case <-stopChan:
-// 			c.Render(-1, common.CustomEvent{Data: "data: [DONE]"})
-// 			return false
-// 		}
-// 	})
-// 	err := resp.Body.Close()
-// 	if err != nil {
-// 		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	return nil, &usage
-// }
-
-// func aliHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, *Usage) {
-// 	var aliResponse AliChatResponse
-// 	responseBody, err := io.ReadAll(resp.Body)
-// 	if err != nil {
-// 		return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	err = resp.Body.Close()
-// 	if err != nil {
-// 		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	err = json.Unmarshal(responseBody, &aliResponse)
-// 	if err != nil {
-// 		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	if aliResponse.Code != "" {
-// 		return &OpenAIErrorWithStatusCode{
-// 			OpenAIError: OpenAIError{
-// 				Message: aliResponse.Message,
-// 				Type:    aliResponse.Code,
-// 				Param:   aliResponse.RequestId,
-// 				Code:    aliResponse.Code,
-// 			},
-// 			StatusCode: resp.StatusCode,
-// 		}, nil
-// 	}
-// 	fullTextResponse := responseAli2OpenAI(&aliResponse)
-// 	jsonResponse, err := json.Marshal(fullTextResponse)
-// 	if err != nil {
-// 		return errorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	c.Writer.Header().Set("Content-Type", "application/json")
-// 	c.Writer.WriteHeader(resp.StatusCode)
-// 	_, err = c.Writer.Write(jsonResponse)
-// 	return nil, &fullTextResponse.Usage
-// }

controller/relay-audio.go

@@ -1,262 +0,0 @@
-package controller
-
-import (
-	"bufio"
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"github.com/gin-gonic/gin"
-	"io"
-	"net/http"
-	"one-api/common"
-	"one-api/model"
-	"strings"
-)
-
-func relayAudioHelper(c *gin.Context, relayMode int) *OpenAIErrorWithStatusCode {
-	audioModel := "whisper-1"
-
-	tokenId := c.GetInt("token_id")
-	channelType := c.GetInt("channel")
-	channelId := c.GetInt("channel_id")
-	userId := c.GetInt("id")
-	group := c.GetString("group")
-	tokenName := c.GetString("token_name")
-
-	var ttsRequest TextToSpeechRequest
-	if relayMode == RelayModeAudioSpeech {
-		// Read JSON
-		err := common.UnmarshalBodyReusable(c, &ttsRequest)
-		// Check if JSON is valid
-		if err != nil {
-			return errorWrapper(err, "invalid_json", http.StatusBadRequest)
-		}
-		audioModel = ttsRequest.Model
-		// Check if text is too long 4096
-		if len(ttsRequest.Input) > 4096 {
-			return errorWrapper(errors.New("input is too long (over 4096 characters)"), "text_too_long", http.StatusBadRequest)
-		}
-	}
-
-	modelRatio := common.GetModelRatio(audioModel)
-	groupRatio := common.GetGroupRatio(group)
-	ratio := modelRatio * groupRatio
-	var quota int
-	var preConsumedQuota int
-	switch relayMode {
-	case RelayModeAudioSpeech:
-		preConsumedQuota = int(float64(len(ttsRequest.Input)) * ratio)
-		quota = preConsumedQuota
-	default:
-		preConsumedQuota = int(float64(common.PreConsumedQuota) * ratio)
-	}
-	userQuota, err := model.CacheGetUserQuota(userId)
-	if err != nil {
-		return errorWrapper(err, "get_user_quota_failed", http.StatusInternalServerError)
-	}
-
-	// Check if user quota is enough
-	if userQuota-preConsumedQuota < 0 {
-		return errorWrapper(errors.New("user quota is not enough"), "insufficient_user_quota", http.StatusForbidden)
-	}
-	err = model.CacheDecreaseUserQuota(userId, preConsumedQuota)
-	if err != nil {
-		return errorWrapper(err, "decrease_user_quota_failed", http.StatusInternalServerError)
-	}
-	if userQuota > 100*preConsumedQuota {
-		// in this case, we do not pre-consume quota
-		// because the user has enough quota
-		preConsumedQuota = 0
-	}
-	if preConsumedQuota > 0 {
-		err := model.PreConsumeTokenQuota(tokenId, preConsumedQuota)
-		if err != nil {
-			return errorWrapper(err, "pre_consume_token_quota_failed", http.StatusForbidden)
-		}
-	}
-
-	// map model name
-	modelMapping := c.GetString("model_mapping")
-	if modelMapping != "" {
-		modelMap := make(map[string]string)
-		err := json.Unmarshal([]byte(modelMapping), &modelMap)
-		if err != nil {
-			return errorWrapper(err, "unmarshal_model_mapping_failed", http.StatusInternalServerError)
-		}
-		if modelMap[audioModel] != "" {
-			audioModel = modelMap[audioModel]
-		}
-	}
-
-	baseURL := common.ChannelBaseURLs[channelType]
-	requestURL := c.Request.URL.String()
-	if c.GetString("base_url") != "" {
-		baseURL = c.GetString("base_url")
-	}
-
-	fullRequestURL := getFullRequestURL(baseURL, requestURL, channelType)
-	if relayMode == RelayModeAudioTranscription && channelType == common.ChannelTypeAzure {
-		// https://learn.microsoft.com/en-us/azure/ai-services/openai/whisper-quickstart?tabs=command-line#rest-api
-		apiVersion := GetAPIVersion(c)
-		fullRequestURL = fmt.Sprintf("%s/openai/deployments/%s/audio/transcriptions?api-version=%s", baseURL, audioModel, apiVersion)
-	}
-
-	requestBody := &bytes.Buffer{}
-	_, err = io.Copy(requestBody, c.Request.Body)
-	if err != nil {
-		return errorWrapper(err, "new_request_body_failed", http.StatusInternalServerError)
-	}
-	c.Request.Body = io.NopCloser(bytes.NewBuffer(requestBody.Bytes()))
-	responseFormat := c.DefaultPostForm("response_format", "json")
-
-	req, err := http.NewRequest(c.Request.Method, fullRequestURL, requestBody)
-	if err != nil {
-		return errorWrapper(err, "new_request_failed", http.StatusInternalServerError)
-	}
-
-	if relayMode == RelayModeAudioTranscription && channelType == common.ChannelTypeAzure {
-		// https://learn.microsoft.com/en-us/azure/ai-services/openai/whisper-quickstart?tabs=command-line#rest-api
-		apiKey := c.Request.Header.Get("Authorization")
-		apiKey = strings.TrimPrefix(apiKey, "Bearer ")
-		req.Header.Set("api-key", apiKey)
-		req.ContentLength = c.Request.ContentLength
-	} else {
-		req.Header.Set("Authorization", c.Request.Header.Get("Authorization"))
-	}
-	req.Header.Set("Content-Type", c.Request.Header.Get("Content-Type"))
-	req.Header.Set("Accept", c.Request.Header.Get("Accept"))
-
-	resp, err := httpClient.Do(req)
-	if err != nil {
-		return errorWrapper(err, "do_request_failed", http.StatusInternalServerError)
-	}
-
-	err = req.Body.Close()
-	if err != nil {
-		return errorWrapper(err, "close_request_body_failed", http.StatusInternalServerError)
-	}
-	err = c.Request.Body.Close()
-	if err != nil {
-		return errorWrapper(err, "close_request_body_failed", http.StatusInternalServerError)
-	}
-
-	if relayMode != RelayModeAudioSpeech {
-		responseBody, err := io.ReadAll(resp.Body)
-		if err != nil {
-			return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError)
-		}
-		err = resp.Body.Close()
-		if err != nil {
-			return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError)
-		}
-
-		var openAIErr TextResponse
-		if err = json.Unmarshal(responseBody, &openAIErr); err == nil {
-			if openAIErr.Error.Message != "" {
-				return errorWrapper(fmt.Errorf("type %s, code %v, message %s", openAIErr.Error.Type, openAIErr.Error.Code, openAIErr.Error.Message), "request_error", http.StatusInternalServerError)
-			}
-		}
-
-		var text string
-		switch responseFormat {
-		case "json":
-			text, err = getTextFromJSON(responseBody)
-		case "text":
-			text, err = getTextFromText(responseBody)
-		case "srt":
-			text, err = getTextFromSRT(responseBody)
-		case "verbose_json":
-			text, err = getTextFromVerboseJSON(responseBody)
-		case "vtt":
-			text, err = getTextFromVTT(responseBody)
-		default:
-			return errorWrapper(errors.New("unexpected_response_format"), "unexpected_response_format", http.StatusInternalServerError)
-		}
-		if err != nil {
-			return errorWrapper(err, "get_text_from_body_err", http.StatusInternalServerError)
-		}
-		quota = countTokenText(text, audioModel)
-		resp.Body = io.NopCloser(bytes.NewBuffer(responseBody))
-	}
-	if resp.StatusCode != http.StatusOK {
-		if preConsumedQuota > 0 {
-			// we need to roll back the pre-consumed quota
-			defer func(ctx context.Context) {
-				go func() {
-					// negative means add quota back for token & user
-					err := model.PostConsumeTokenQuota(tokenId, -preConsumedQuota)
-					if err != nil {
-						common.LogError(ctx, fmt.Sprintf("error rollback pre-consumed quota: %s", err.Error()))
-					}
-				}()
-			}(c.Request.Context())
-		}
-		return relayErrorHandler(resp)
-	}
-	quotaDelta := quota - preConsumedQuota
-	defer func(ctx context.Context) {
-		go postConsumeQuota(ctx, tokenId, quotaDelta, quota, userId, channelId, modelRatio, groupRatio, audioModel, tokenName)
-	}(c.Request.Context())
-
-	for k, v := range resp.Header {
-		c.Writer.Header().Set(k, v[0])
-	}
-	c.Writer.WriteHeader(resp.StatusCode)
-
-	_, err = io.Copy(c.Writer, resp.Body)
-	if err != nil {
-		return errorWrapper(err, "copy_response_body_failed", http.StatusInternalServerError)
-	}
-	err = resp.Body.Close()
-	if err != nil {
-		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError)
-	}
-	return nil
-}
-
-func getTextFromVTT(body []byte) (string, error) {
-	return getTextFromSRT(body)
-}
-
-func getTextFromVerboseJSON(body []byte) (string, error) {
-	var whisperResponse WhisperVerboseJSONResponse
-	if err := json.Unmarshal(body, &whisperResponse); err != nil {
-		return "", fmt.Errorf("unmarshal_response_body_failed err :%w", err)
-	}
-	return whisperResponse.Text, nil
-}
-
-func getTextFromSRT(body []byte) (string, error) {
-	scanner := bufio.NewScanner(strings.NewReader(string(body)))
-	var builder strings.Builder
-	var textLine bool
-	for scanner.Scan() {
-		line := scanner.Text()
-		if textLine {
-			builder.WriteString(line)
-			textLine = false
-			continue
-		} else if strings.Contains(line, "-->") {
-			textLine = true
-			continue
-		}
-	}
-	if err := scanner.Err(); err != nil {
-		return "", err
-	}
-	return builder.String(), nil
-}
-
-func getTextFromText(body []byte) (string, error) {
-	return strings.TrimSuffix(string(body), "\n"), nil
-}
-
-func getTextFromJSON(body []byte) (string, error) {
-	var whisperResponse WhisperJSONResponse
-	if err := json.Unmarshal(body, &whisperResponse); err != nil {
-		return "", fmt.Errorf("unmarshal_response_body_failed err :%w", err)
-	}
-	return whisperResponse.Text, nil
-}

controller/relay-baidu.go

@@ -1,359 +0,0 @@
-package controller
-
-// import (
-// 	"bufio"
-// 	"encoding/json"
-// 	"errors"
-// 	"fmt"
-// 	"github.com/gin-gonic/gin"
-// 	"io"
-// 	"net/http"
-// 	"one-api/common"
-// 	"strings"
-// 	"sync"
-// 	"time"
-// )
-
-// // https://cloud.baidu.com/doc/WENXINWORKSHOP/s/flfmc9do2
-
-// type BaiduTokenResponse struct {
-// 	ExpiresIn   int    `json:"expires_in"`
-// 	AccessToken string `json:"access_token"`
-// }
-
-// type BaiduMessage struct {
-// 	Role    string `json:"role"`
-// 	Content string `json:"content"`
-// }
-
-// type BaiduChatRequest struct {
-// 	Messages []BaiduMessage `json:"messages"`
-// 	Stream   bool           `json:"stream"`
-// 	UserId   string         `json:"user_id,omitempty"`
-// }
-
-// type BaiduError struct {
-// 	ErrorCode int    `json:"error_code"`
-// 	ErrorMsg  string `json:"error_msg"`
-// }
-
-// type BaiduChatResponse struct {
-// 	Id               string `json:"id"`
-// 	Object           string `json:"object"`
-// 	Created          int64  `json:"created"`
-// 	Result           string `json:"result"`
-// 	IsTruncated      bool   `json:"is_truncated"`
-// 	NeedClearHistory bool   `json:"need_clear_history"`
-// 	Usage            Usage  `json:"usage"`
-// 	BaiduError
-// }
-
-// type BaiduChatStreamResponse struct {
-// 	BaiduChatResponse
-// 	SentenceId int  `json:"sentence_id"`
-// 	IsEnd      bool `json:"is_end"`
-// }
-
-// type BaiduEmbeddingRequest struct {
-// 	Input []string `json:"input"`
-// }
-
-// type BaiduEmbeddingData struct {
-// 	Object    string    `json:"object"`
-// 	Embedding []float64 `json:"embedding"`
-// 	Index     int       `json:"index"`
-// }
-
-// type BaiduEmbeddingResponse struct {
-// 	Id      string               `json:"id"`
-// 	Object  string               `json:"object"`
-// 	Created int64                `json:"created"`
-// 	Data    []BaiduEmbeddingData `json:"data"`
-// 	Usage   Usage                `json:"usage"`
-// 	BaiduError
-// }
-
-// type BaiduAccessToken struct {
-// 	AccessToken      string    `json:"access_token"`
-// 	Error            string    `json:"error,omitempty"`
-// 	ErrorDescription string    `json:"error_description,omitempty"`
-// 	ExpiresIn        int64     `json:"expires_in,omitempty"`
-// 	ExpiresAt        time.Time `json:"-"`
-// }
-
-// var baiduTokenStore sync.Map
-
-// func requestOpenAI2Baidu(request GeneralOpenAIRequest) *BaiduChatRequest {
-// 	messages := make([]BaiduMessage, 0, len(request.Messages))
-// 	for _, message := range request.Messages {
-// 		if message.Role == "system" {
-// 			messages = append(messages, BaiduMessage{
-// 				Role:    "user",
-// 				Content: message.Content,
-// 			})
-// 			messages = append(messages, BaiduMessage{
-// 				Role:    "assistant",
-// 				Content: "Okay",
-// 			})
-// 		} else {
-// 			messages = append(messages, BaiduMessage{
-// 				Role:    message.Role,
-// 				Content: message.Content,
-// 			})
-// 		}
-// 	}
-// 	return &BaiduChatRequest{
-// 		Messages: messages,
-// 		Stream:   request.Stream,
-// 	}
-// }
-
-// func responseBaidu2OpenAI(response *BaiduChatResponse) *OpenAITextResponse {
-// 	choice := OpenAITextResponseChoice{
-// 		Index: 0,
-// 		Message: Message{
-// 			Role:    "assistant",
-// 			Content: response.Result,
-// 		},
-// 		FinishReason: "stop",
-// 	}
-// 	fullTextResponse := OpenAITextResponse{
-// 		Id:      response.Id,
-// 		Object:  "chat.completion",
-// 		Created: response.Created,
-// 		Choices: []OpenAITextResponseChoice{choice},
-// 		Usage:   response.Usage,
-// 	}
-// 	return &fullTextResponse
-// }
-
-// func streamResponseBaidu2OpenAI(baiduResponse *BaiduChatStreamResponse) *ChatCompletionsStreamResponse {
-// 	var choice ChatCompletionsStreamResponseChoice
-// 	choice.Delta.Content = baiduResponse.Result
-// 	if baiduResponse.IsEnd {
-// 		choice.FinishReason = &stopFinishReason
-// 	}
-// 	response := ChatCompletionsStreamResponse{
-// 		Id:      baiduResponse.Id,
-// 		Object:  "chat.completion.chunk",
-// 		Created: baiduResponse.Created,
-// 		Model:   "ernie-bot",
-// 		Choices: []ChatCompletionsStreamResponseChoice{choice},
-// 	}
-// 	return &response
-// }
-
-// func embeddingRequestOpenAI2Baidu(request GeneralOpenAIRequest) *BaiduEmbeddingRequest {
-// 	return &BaiduEmbeddingRequest{
-// 		Input: request.ParseInput(),
-// 	}
-// }
-
-// func embeddingResponseBaidu2OpenAI(response *BaiduEmbeddingResponse) *OpenAIEmbeddingResponse {
-// 	openAIEmbeddingResponse := OpenAIEmbeddingResponse{
-// 		Object: "list",
-// 		Data:   make([]OpenAIEmbeddingResponseItem, 0, len(response.Data)),
-// 		Model:  "baidu-embedding",
-// 		Usage:  response.Usage,
-// 	}
-// 	for _, item := range response.Data {
-// 		openAIEmbeddingResponse.Data = append(openAIEmbeddingResponse.Data, OpenAIEmbeddingResponseItem{
-// 			Object:    item.Object,
-// 			Index:     item.Index,
-// 			Embedding: item.Embedding,
-// 		})
-// 	}
-// 	return &openAIEmbeddingResponse
-// }
-
-// func baiduStreamHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, *Usage) {
-// 	var usage Usage
-// 	scanner := bufio.NewScanner(resp.Body)
-// 	scanner.Split(func(data []byte, atEOF bool) (advance int, token []byte, err error) {
-// 		if atEOF && len(data) == 0 {
-// 			return 0, nil, nil
-// 		}
-// 		if i := strings.Index(string(data), "\n"); i >= 0 {
-// 			return i + 1, data[0:i], nil
-// 		}
-// 		if atEOF {
-// 			return len(data), data, nil
-// 		}
-// 		return 0, nil, nil
-// 	})
-// 	dataChan := make(chan string)
-// 	stopChan := make(chan bool)
-// 	go func() {
-// 		for scanner.Scan() {
-// 			data := scanner.Text()
-// 			if len(data) < 6 { // ignore blank line or wrong format
-// 				continue
-// 			}
-// 			data = data[6:]
-// 			dataChan <- data
-// 		}
-// 		stopChan <- true
-// 	}()
-// 	setEventStreamHeaders(c)
-// 	c.Stream(func(w io.Writer) bool {
-// 		select {
-// 		case data := <-dataChan:
-// 			var baiduResponse BaiduChatStreamResponse
-// 			err := json.Unmarshal([]byte(data), &baiduResponse)
-// 			if err != nil {
-// 				common.SysError("error unmarshalling stream response: " + err.Error())
-// 				return true
-// 			}
-// 			if baiduResponse.Usage.TotalTokens != 0 {
-// 				usage.TotalTokens = baiduResponse.Usage.TotalTokens
-// 				usage.PromptTokens = baiduResponse.Usage.PromptTokens
-// 				usage.CompletionTokens = baiduResponse.Usage.TotalTokens - baiduResponse.Usage.PromptTokens
-// 			}
-// 			response := streamResponseBaidu2OpenAI(&baiduResponse)
-// 			jsonResponse, err := json.Marshal(response)
-// 			if err != nil {
-// 				common.SysError("error marshalling stream response: " + err.Error())
-// 				return true
-// 			}
-// 			c.Render(-1, common.CustomEvent{Data: "data: " + string(jsonResponse)})
-// 			return true
-// 		case <-stopChan:
-// 			c.Render(-1, common.CustomEvent{Data: "data: [DONE]"})
-// 			return false
-// 		}
-// 	})
-// 	err := resp.Body.Close()
-// 	if err != nil {
-// 		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	return nil, &usage
-// }
-
-// func baiduHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, *Usage) {
-// 	var baiduResponse BaiduChatResponse
-// 	responseBody, err := io.ReadAll(resp.Body)
-// 	if err != nil {
-// 		return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	err = resp.Body.Close()
-// 	if err != nil {
-// 		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	err = json.Unmarshal(responseBody, &baiduResponse)
-// 	if err != nil {
-// 		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	if baiduResponse.ErrorMsg != "" {
-// 		return &OpenAIErrorWithStatusCode{
-// 			OpenAIError: OpenAIError{
-// 				Message: baiduResponse.ErrorMsg,
-// 				Type:    "baidu_error",
-// 				Param:   "",
-// 				Code:    baiduResponse.ErrorCode,
-// 			},
-// 			StatusCode: resp.StatusCode,
-// 		}, nil
-// 	}
-// 	fullTextResponse := responseBaidu2OpenAI(&baiduResponse)
-// 	jsonResponse, err := json.Marshal(fullTextResponse)
-// 	if err != nil {
-// 		return errorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	c.Writer.Header().Set("Content-Type", "application/json")
-// 	c.Writer.WriteHeader(resp.StatusCode)
-// 	_, err = c.Writer.Write(jsonResponse)
-// 	return nil, &fullTextResponse.Usage
-// }
-
-// func baiduEmbeddingHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, *Usage) {
-// 	var baiduResponse BaiduEmbeddingResponse
-// 	responseBody, err := io.ReadAll(resp.Body)
-// 	if err != nil {
-// 		return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	err = resp.Body.Close()
-// 	if err != nil {
-// 		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	err = json.Unmarshal(responseBody, &baiduResponse)
-// 	if err != nil {
-// 		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	if baiduResponse.ErrorMsg != "" {
-// 		return &OpenAIErrorWithStatusCode{
-// 			OpenAIError: OpenAIError{
-// 				Message: baiduResponse.ErrorMsg,
-// 				Type:    "baidu_error",
-// 				Param:   "",
-// 				Code:    baiduResponse.ErrorCode,
-// 			},
-// 			StatusCode: resp.StatusCode,
-// 		}, nil
-// 	}
-// 	fullTextResponse := embeddingResponseBaidu2OpenAI(&baiduResponse)
-// 	jsonResponse, err := json.Marshal(fullTextResponse)
-// 	if err != nil {
-// 		return errorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	c.Writer.Header().Set("Content-Type", "application/json")
-// 	c.Writer.WriteHeader(resp.StatusCode)
-// 	_, err = c.Writer.Write(jsonResponse)
-// 	return nil, &fullTextResponse.Usage
-// }
-
-// func getBaiduAccessToken(apiKey string) (string, error) {
-// 	if val, ok := baiduTokenStore.Load(apiKey); ok {
-// 		var accessToken BaiduAccessToken
-// 		if accessToken, ok = val.(BaiduAccessToken); ok {
-// 			// soon this will expire
-// 			if time.Now().Add(time.Hour).After(accessToken.ExpiresAt) {
-// 				go func() {
-// 					_, _ = getBaiduAccessTokenHelper(apiKey)
-// 				}()
-// 			}
-// 			return accessToken.AccessToken, nil
-// 		}
-// 	}
-// 	accessToken, err := getBaiduAccessTokenHelper(apiKey)
-// 	if err != nil {
-// 		return "", err
-// 	}
-// 	if accessToken == nil {
-// 		return "", errors.New("getBaiduAccessToken return a nil token")
-// 	}
-// 	return (*accessToken).AccessToken, nil
-// }
-
-// func getBaiduAccessTokenHelper(apiKey string) (*BaiduAccessToken, error) {
-// 	parts := strings.Split(apiKey, "|")
-// 	if len(parts) != 2 {
-// 		return nil, errors.New("invalid baidu apikey")
-// 	}
-// 	req, err := http.NewRequest("POST", fmt.Sprintf("https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id=%s&client_secret=%s",
-// 		parts[0], parts[1]), nil)
-// 	if err != nil {
-// 		return nil, err
-// 	}
-// 	req.Header.Add("Content-Type", "application/json")
-// 	req.Header.Add("Accept", "application/json")
-// 	res, err := impatientHTTPClient.Do(req)
-// 	if err != nil {
-// 		return nil, err
-// 	}
-// 	defer res.Body.Close()
-
-// 	var accessToken BaiduAccessToken
-// 	err = json.NewDecoder(res.Body).Decode(&accessToken)
-// 	if err != nil {
-// 		return nil, err
-// 	}
-// 	if accessToken.Error != "" {
-// 		return nil, errors.New(accessToken.Error + ": " + accessToken.ErrorDescription)
-// 	}
-// 	if accessToken.AccessToken == "" {
-// 		return nil, errors.New("getBaiduAccessTokenHelper get empty access token")
-// 	}
-// 	accessToken.ExpiresAt = time.Now().Add(time.Duration(accessToken.ExpiresIn) * time.Second)
-// 	baiduTokenStore.Store(apiKey, accessToken)
-// 	return &accessToken, nil
-// }

controller/relay-claude.go

@@ -1,230 +0,0 @@
-package controller
-
-import (
-	"bufio"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"one-api/common"
-	"strings"
-
-	"github.com/gin-gonic/gin"
-)
-
-type ClaudeMetadata struct {
-	UserId string `json:"user_id"`
-}
-
-type ClaudeRequest struct {
-	Model             string   `json:"model"`
-	Prompt            string   `json:"prompt"`
-	MaxTokensToSample int      `json:"max_tokens_to_sample"`
-	StopSequences     []string `json:"stop_sequences,omitempty"`
-	Temperature       float64  `json:"temperature,omitempty"`
-	TopP              float64  `json:"top_p,omitempty"`
-	TopK              int      `json:"top_k,omitempty"`
-	//ClaudeMetadata    `json:"metadata,omitempty"`
-	Stream bool `json:"stream,omitempty"`
-}
-
-type ClaudeError struct {
-	Type    string `json:"type"`
-	Message string `json:"message"`
-}
-
-type ClaudeResponse struct {
-	Completion string      `json:"completion"`
-	StopReason string      `json:"stop_reason"`
-	Model      string      `json:"model"`
-	Error      ClaudeError `json:"error"`
-}
-
-func stopReasonClaude2OpenAI(reason string) string {
-	switch reason {
-	case "stop_sequence":
-		return "stop"
-	case "max_tokens":
-		return "length"
-	default:
-		return reason
-	}
-}
-
-func requestOpenAI2Claude(textRequest GeneralOpenAIRequest) *ClaudeRequest {
-	claudeRequest := ClaudeRequest{
-		Model:             textRequest.Model,
-		Prompt:            "",
-		MaxTokensToSample: textRequest.MaxTokens,
-		StopSequences:     nil,
-		Temperature:       textRequest.Temperature,
-		TopP:              textRequest.TopP,
-		Stream:            textRequest.Stream,
-	}
-	if claudeRequest.MaxTokensToSample == 0 {
-		claudeRequest.MaxTokensToSample = 1000000
-	}
-	prompt := ""
-
-	// messages, err := textRequest.TextMessages()
-	// if err != nil {
-	// 	log.Panicf("invalid message type: %T", textRequest.Messages)
-	// }
-
-	for _, message := range textRequest.Messages {
-		if message.Role == "user" {
-			prompt += fmt.Sprintf("\n\nHuman: %s", message.Content)
-		} else if message.Role == "assistant" {
-			prompt += fmt.Sprintf("\n\nAssistant: %s", message.Content)
-		} else if message.Role == "system" {
-			if prompt == "" {
-				prompt = message.StringContent()
-			}
-		}
-	}
-	prompt += "\n\nAssistant:"
-	claudeRequest.Prompt = prompt
-	return &claudeRequest
-}
-
-func streamResponseClaude2OpenAI(claudeResponse *ClaudeResponse) *ChatCompletionsStreamResponse {
-	var choice ChatCompletionsStreamResponseChoice
-	choice.Delta.Content = claudeResponse.Completion
-	finishReason := stopReasonClaude2OpenAI(claudeResponse.StopReason)
-	if finishReason != "null" {
-		choice.FinishReason = &finishReason
-	}
-	var response ChatCompletionsStreamResponse
-	response.Object = "chat.completion.chunk"
-	response.Model = claudeResponse.Model
-	response.Choices = []ChatCompletionsStreamResponseChoice{choice}
-	return &response
-}
-
-func responseClaude2OpenAI(claudeResponse *ClaudeResponse) *OpenAITextResponse {
-	choice := OpenAITextResponseChoice{
-		Index: 0,
-		Message: Message{
-			Role:    "assistant",
-			Content: strings.TrimPrefix(claudeResponse.Completion, " "),
-			Name:    nil,
-		},
-		FinishReason: stopReasonClaude2OpenAI(claudeResponse.StopReason),
-	}
-	fullTextResponse := OpenAITextResponse{
-		Id:      fmt.Sprintf("chatcmpl-%s", common.GetUUID()),
-		Object:  "chat.completion",
-		Created: common.GetTimestamp(),
-		Choices: []OpenAITextResponseChoice{choice},
-	}
-	return &fullTextResponse
-}
-
-func claudeStreamHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, string) {
-	responseText := ""
-	responseId := fmt.Sprintf("chatcmpl-%s", common.GetUUID())
-	createdTime := common.GetTimestamp()
-	scanner := bufio.NewScanner(resp.Body)
-	scanner.Split(func(data []byte, atEOF bool) (advance int, token []byte, err error) {
-		if atEOF && len(data) == 0 {
-			return 0, nil, nil
-		}
-		if i := strings.Index(string(data), "\r\n\r\n"); i >= 0 {
-			return i + 4, data[0:i], nil
-		}
-		if atEOF {
-			return len(data), data, nil
-		}
-		return 0, nil, nil
-	})
-	dataChan := make(chan string)
-	stopChan := make(chan bool)
-	go func() {
-		for scanner.Scan() {
-			data := scanner.Text()
-			if !strings.HasPrefix(data, "event: completion") {
-				continue
-			}
-			data = strings.TrimPrefix(data, "event: completion\r\ndata: ")
-			dataChan <- data
-		}
-		stopChan <- true
-	}()
-	setEventStreamHeaders(c)
-	c.Stream(func(w io.Writer) bool {
-		select {
-		case data := <-dataChan:
-			// some implementations may add \r at the end of data
-			data = strings.TrimSuffix(data, "\r")
-			var claudeResponse ClaudeResponse
-			err := json.Unmarshal([]byte(data), &claudeResponse)
-			if err != nil {
-				common.SysError("error unmarshalling stream response: " + err.Error())
-				return true
-			}
-			responseText += claudeResponse.Completion
-			response := streamResponseClaude2OpenAI(&claudeResponse)
-			response.Id = responseId
-			response.Created = createdTime
-			jsonStr, err := json.Marshal(response)
-			if err != nil {
-				common.SysError("error marshalling stream response: " + err.Error())
-				return true
-			}
-			c.Render(-1, common.CustomEvent{Data: "data: " + string(jsonStr)})
-			return true
-		case <-stopChan:
-			c.Render(-1, common.CustomEvent{Data: "data: [DONE]"})
-			return false
-		}
-	})
-	err := resp.Body.Close()
-	if err != nil {
-		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), ""
-	}
-	return nil, responseText
-}
-
-func claudeHandler(c *gin.Context, resp *http.Response, promptTokens int, model string) (*OpenAIErrorWithStatusCode, *Usage) {
-	responseBody, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
-	}
-	err = resp.Body.Close()
-	if err != nil {
-		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
-	}
-	var claudeResponse ClaudeResponse
-	err = json.Unmarshal(responseBody, &claudeResponse)
-	if err != nil {
-		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
-	}
-	if claudeResponse.Error.Type != "" {
-		return &OpenAIErrorWithStatusCode{
-			OpenAIError: OpenAIError{
-				Message: claudeResponse.Error.Message,
-				Type:    claudeResponse.Error.Type,
-				Param:   "",
-				Code:    claudeResponse.Error.Type,
-			},
-			StatusCode: resp.StatusCode,
-		}, nil
-	}
-	fullTextResponse := responseClaude2OpenAI(&claudeResponse)
-	fullTextResponse.Model = model
-	completionTokens := countTokenText(claudeResponse.Completion, model)
-	usage := Usage{
-		PromptTokens:     promptTokens,
-		CompletionTokens: completionTokens,
-		TotalTokens:      promptTokens + completionTokens,
-	}
-	fullTextResponse.Usage = usage
-	jsonResponse, err := json.Marshal(fullTextResponse)
-	if err != nil {
-		return errorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
-	}
-	c.Writer.Header().Set("Content-Type", "application/json")
-	c.Writer.WriteHeader(resp.StatusCode)
-	_, err = c.Writer.Write(jsonResponse)
-	return nil, &usage
-}

controller/relay-gemini.go

@@ -1,347 +0,0 @@
-package controller
-
-import (
-	"bufio"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"one-api/common"
-	"one-api/common/image"
-	"strings"
-
-	"github.com/gin-gonic/gin"
-)
-
-// https://ai.google.dev/docs/gemini_api_overview?hl=zh-cn
-
-const (
-	GeminiVisionMaxImageNum = 16
-)
-
-type GeminiChatRequest struct {
-	Contents         []GeminiChatContent        `json:"contents"`
-	SafetySettings   []GeminiChatSafetySettings `json:"safety_settings,omitempty"`
-	GenerationConfig GeminiChatGenerationConfig `json:"generation_config,omitempty"`
-	Tools            []GeminiChatTools          `json:"tools,omitempty"`
-}
-
-type GeminiInlineData struct {
-	MimeType string `json:"mimeType"`
-	Data     string `json:"data"`
-}
-
-type GeminiPart struct {
-	Text       string            `json:"text,omitempty"`
-	InlineData *GeminiInlineData `json:"inlineData,omitempty"`
-}
-
-type GeminiChatContent struct {
-	Role  string       `json:"role,omitempty"`
-	Parts []GeminiPart `json:"parts"`
-}
-
-type GeminiChatSafetySettings struct {
-	Category  string `json:"category"`
-	Threshold string `json:"threshold"`
-}
-
-type GeminiChatTools struct {
-	FunctionDeclarations any `json:"functionDeclarations,omitempty"`
-}
-
-type GeminiChatGenerationConfig struct {
-	Temperature     float64  `json:"temperature,omitempty"`
-	TopP            float64  `json:"topP,omitempty"`
-	TopK            float64  `json:"topK,omitempty"`
-	MaxOutputTokens int      `json:"maxOutputTokens,omitempty"`
-	CandidateCount  int      `json:"candidateCount,omitempty"`
-	StopSequences   []string `json:"stopSequences,omitempty"`
-}
-
-// Setting safety to the lowest possible values since Gemini is already powerless enough
-func requestOpenAI2Gemini(textRequest GeneralOpenAIRequest) *GeminiChatRequest {
-	geminiRequest := GeminiChatRequest{
-		Contents: make([]GeminiChatContent, 0, len(textRequest.Messages)),
-		SafetySettings: []GeminiChatSafetySettings{
-			{
-				Category:  "HARM_CATEGORY_HARASSMENT",
-				Threshold: common.GeminiSafetySetting,
-			},
-			{
-				Category:  "HARM_CATEGORY_HATE_SPEECH",
-				Threshold: common.GeminiSafetySetting,
-			},
-			{
-				Category:  "HARM_CATEGORY_SEXUALLY_EXPLICIT",
-				Threshold: common.GeminiSafetySetting,
-			},
-			{
-				Category:  "HARM_CATEGORY_DANGEROUS_CONTENT",
-				Threshold: common.GeminiSafetySetting,
-			},
-		},
-		GenerationConfig: GeminiChatGenerationConfig{
-			Temperature:     textRequest.Temperature,
-			TopP:            textRequest.TopP,
-			MaxOutputTokens: textRequest.MaxTokens,
-		},
-	}
-	if textRequest.Functions != nil {
-		geminiRequest.Tools = []GeminiChatTools{
-			{
-				FunctionDeclarations: textRequest.Functions,
-			},
-		}
-	}
-	shouldAddDummyModelMessage := false
-	for _, message := range textRequest.Messages {
-		content := GeminiChatContent{
-			Role: message.Role,
-			Parts: []GeminiPart{
-				{
-					Text: message.StringContent(),
-				},
-			},
-		}
-		openaiContent := message.ParseContent()
-		var parts []GeminiPart
-		imageNum := 0
-		for _, part := range openaiContent {
-			if part.Type == ContentTypeText {
-				parts = append(parts, GeminiPart{
-					Text: part.Text,
-				})
-			} else if part.Type == ContentTypeImageURL {
-				imageNum += 1
-				if imageNum > GeminiVisionMaxImageNum {
-					continue
-				}
-
-				mimeType, data, err := image.GetImageFromUrl(part.ImageURL.Url)
-				if err != nil {
-					common.LogWarn(context.TODO(),
-						fmt.Sprintf("get image from url %s got %+v", part.ImageURL.Url, err))
-					continue
-				}
-
-				parts = append(parts, GeminiPart{
-					InlineData: &GeminiInlineData{
-						MimeType: mimeType,
-						Data:     data,
-					},
-				})
-			}
-		}
-		common.LogInfo(context.TODO(),
-			fmt.Sprintf("send %d images to gemini-pro-vision", len(parts)))
-		content.Parts = parts
-
-		// there's no assistant role in gemini and API shall vomit if Role is not user or model
-		if content.Role == "assistant" {
-			content.Role = "model"
-		}
-		// Converting system prompt to prompt from user for the same reason
-		if content.Role == "system" {
-			content.Role = "user"
-			shouldAddDummyModelMessage = true
-		}
-		geminiRequest.Contents = append(geminiRequest.Contents, content)
-
-		// If a system message is the last message, we need to add a dummy model message to make gemini happy
-		if shouldAddDummyModelMessage {
-			geminiRequest.Contents = append(geminiRequest.Contents, GeminiChatContent{
-				Role: "model",
-				Parts: []GeminiPart{
-					{
-						Text: "Okay",
-					},
-				},
-			})
-			shouldAddDummyModelMessage = false
-		}
-	}
-
-	return &geminiRequest
-}
-
-type GeminiChatResponse struct {
-	Candidates     []GeminiChatCandidate    `json:"candidates"`
-	PromptFeedback GeminiChatPromptFeedback `json:"promptFeedback"`
-}
-
-func (g *GeminiChatResponse) GetResponseText() string {
-	if g == nil {
-		return ""
-	}
-	if len(g.Candidates) > 0 && len(g.Candidates[0].Content.Parts) > 0 {
-		return g.Candidates[0].Content.Parts[0].Text
-	}
-	return ""
-}
-
-type GeminiChatCandidate struct {
-	Content       GeminiChatContent        `json:"content"`
-	FinishReason  string                   `json:"finishReason"`
-	Index         int64                    `json:"index"`
-	SafetyRatings []GeminiChatSafetyRating `json:"safetyRatings"`
-}
-
-type GeminiChatSafetyRating struct {
-	Category    string `json:"category"`
-	Probability string `json:"probability"`
-}
-
-type GeminiChatPromptFeedback struct {
-	SafetyRatings []GeminiChatSafetyRating `json:"safetyRatings"`
-}
-
-func responseGeminiChat2OpenAI(response *GeminiChatResponse) *OpenAITextResponse {
-	fullTextResponse := OpenAITextResponse{
-		Id:      fmt.Sprintf("chatcmpl-%s", common.GetUUID()),
-		Object:  "chat.completion",
-		Created: common.GetTimestamp(),
-		Choices: make([]OpenAITextResponseChoice, 0, len(response.Candidates)),
-	}
-	for i, candidate := range response.Candidates {
-		choice := OpenAITextResponseChoice{
-			Index: i,
-			Message: Message{
-				Role:    "assistant",
-				Content: "",
-			},
-			FinishReason: stopFinishReason,
-		}
-		if len(candidate.Content.Parts) > 0 {
-			choice.Message.Content = candidate.Content.Parts[0].Text
-		}
-		fullTextResponse.Choices = append(fullTextResponse.Choices, choice)
-	}
-	return &fullTextResponse
-}
-
-func streamResponseGeminiChat2OpenAI(geminiResponse *GeminiChatResponse) *ChatCompletionsStreamResponse {
-	var choice ChatCompletionsStreamResponseChoice
-	choice.Delta.Content = geminiResponse.GetResponseText()
-	choice.FinishReason = &stopFinishReason
-	var response ChatCompletionsStreamResponse
-	response.Object = "chat.completion.chunk"
-	response.Model = "gemini"
-	response.Choices = []ChatCompletionsStreamResponseChoice{choice}
-	return &response
-}
-
-func geminiChatStreamHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, string) {
-	responseText := ""
-	dataChan := make(chan string)
-	stopChan := make(chan bool)
-	scanner := bufio.NewScanner(resp.Body)
-	scanner.Split(func(data []byte, atEOF bool) (advance int, token []byte, err error) {
-		if atEOF && len(data) == 0 {
-			return 0, nil, nil
-		}
-		if i := strings.Index(string(data), "\n"); i >= 0 {
-			return i + 1, data[0:i], nil
-		}
-		if atEOF {
-			return len(data), data, nil
-		}
-		return 0, nil, nil
-	})
-	go func() {
-		for scanner.Scan() {
-			data := scanner.Text()
-			data = strings.TrimSpace(data)
-			if !strings.HasPrefix(data, "\"text\": \"") {
-				continue
-			}
-			data = strings.TrimPrefix(data, "\"text\": \"")
-			data = strings.TrimSuffix(data, "\"")
-			dataChan <- data
-		}
-		stopChan <- true
-	}()
-	setEventStreamHeaders(c)
-	c.Stream(func(w io.Writer) bool {
-		select {
-		case data := <-dataChan:
-			// this is used to prevent annoying \ related format bug
-			data = fmt.Sprintf("{\"content\": \"%s\"}", data)
-			type dummyStruct struct {
-				Content string `json:"content"`
-			}
-			var dummy dummyStruct
-			err := json.Unmarshal([]byte(data), &dummy)
-			responseText += dummy.Content
-			var choice ChatCompletionsStreamResponseChoice
-			choice.Delta.Content = dummy.Content
-			response := ChatCompletionsStreamResponse{
-				Id:      fmt.Sprintf("chatcmpl-%s", common.GetUUID()),
-				Object:  "chat.completion.chunk",
-				Created: common.GetTimestamp(),
-				Model:   "gemini-pro",
-				Choices: []ChatCompletionsStreamResponseChoice{choice},
-			}
-			jsonResponse, err := json.Marshal(response)
-			if err != nil {
-				common.SysError("error marshalling stream response: " + err.Error())
-				return true
-			}
-			c.Render(-1, common.CustomEvent{Data: "data: " + string(jsonResponse)})
-			return true
-		case <-stopChan:
-			c.Render(-1, common.CustomEvent{Data: "data: [DONE]"})
-			return false
-		}
-	})
-	err := resp.Body.Close()
-	if err != nil {
-		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), ""
-	}
-	return nil, responseText
-}
-
-func geminiChatHandler(c *gin.Context, resp *http.Response, promptTokens int, model string) (*OpenAIErrorWithStatusCode, *Usage) {
-	responseBody, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
-	}
-	err = resp.Body.Close()
-	if err != nil {
-		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
-	}
-	var geminiResponse GeminiChatResponse
-	err = json.Unmarshal(responseBody, &geminiResponse)
-	if err != nil {
-		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
-	}
-	if len(geminiResponse.Candidates) == 0 {
-		return &OpenAIErrorWithStatusCode{
-			OpenAIError: OpenAIError{
-				Message: "No candidates returned",
-				Type:    "server_error",
-				Param:   "",
-				Code:    500,
-			},
-			StatusCode: resp.StatusCode,
-		}, nil
-	}
-	fullTextResponse := responseGeminiChat2OpenAI(&geminiResponse)
-	fullTextResponse.Model = model
-	completionTokens := countTokenText(geminiResponse.GetResponseText(), model)
-	usage := Usage{
-		PromptTokens:     promptTokens,
-		CompletionTokens: completionTokens,
-		TotalTokens:      promptTokens + completionTokens,
-	}
-	fullTextResponse.Usage = usage
-	jsonResponse, err := json.Marshal(fullTextResponse)
-	if err != nil {
-		return errorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
-	}
-	c.Writer.Header().Set("Content-Type", "application/json")
-	c.Writer.WriteHeader(resp.StatusCode)
-	_, err = c.Writer.Write(jsonResponse)
-	return nil, &usage
-}

controller/relay-image.go

@@ -1,222 +0,0 @@
-package controller
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"one-api/common"
-	"one-api/model"
-	"strings"
-
-	"github.com/gin-gonic/gin"
-)
-
-func isWithinRange(element string, value int) bool {
-	if _, ok := common.DalleGenerationImageAmounts[element]; !ok {
-		return false
-	}
-	min := common.DalleGenerationImageAmounts[element][0]
-	max := common.DalleGenerationImageAmounts[element][1]
-
-	return value >= min && value <= max
-}
-
-func relayImageHelper(c *gin.Context, relayMode int) *OpenAIErrorWithStatusCode {
-	imageModel := "dall-e-2"
-	imageSize := "1024x1024"
-
-	tokenId := c.GetInt("token_id")
-	channelType := c.GetInt("channel")
-	channelId := c.GetInt("channel_id")
-	userId := c.GetInt("id")
-	group := c.GetString("group")
-
-	var imageRequest ImageRequest
-	err := common.UnmarshalBodyReusable(c, &imageRequest)
-	if err != nil {
-		return errorWrapper(err, "bind_request_body_failed", http.StatusBadRequest)
-	}
-
-	if imageRequest.N == 0 {
-		imageRequest.N = 1
-	}
-
-	// Size validation
-	if imageRequest.Size != "" {
-		imageSize = imageRequest.Size
-	}
-
-	// Model validation
-	if imageRequest.Model != "" {
-		imageModel = imageRequest.Model
-	}
-
-	imageCostRatio, hasValidSize := common.DalleSizeRatios[imageModel][imageSize]
-
-	// Check if model is supported
-	if hasValidSize {
-		if imageRequest.Quality == "hd" && imageModel == "dall-e-3" {
-			if imageSize == "1024x1024" {
-				imageCostRatio *= 2
-			} else {
-				imageCostRatio *= 1.5
-			}
-		}
-	} else {
-		return errorWrapper(errors.New("size not supported for this image model"), "size_not_supported", http.StatusBadRequest)
-	}
-
-	// Prompt validation
-	if imageRequest.Prompt == "" {
-		return errorWrapper(errors.New("prompt is required"), "prompt_missing", http.StatusBadRequest)
-	}
-
-	// Check prompt length
-	if len(imageRequest.Prompt) > common.DalleImagePromptLengthLimitations[imageModel] {
-		return errorWrapper(errors.New("prompt is too long"), "prompt_too_long", http.StatusBadRequest)
-	}
-
-	// Number of generated images validation
-	if isWithinRange(imageModel, imageRequest.N) == false {
-		// channel not azure
-		if channelType != common.ChannelTypeAzure {
-			return errorWrapper(errors.New("invalid value of n"), "n_not_within_range", http.StatusBadRequest)
-		}
-	}
-
-	// map model name
-	modelMapping := c.GetString("model_mapping")
-	isModelMapped := false
-	if modelMapping != "" {
-		modelMap := make(map[string]string)
-		err := json.Unmarshal([]byte(modelMapping), &modelMap)
-		if err != nil {
-			return errorWrapper(err, "unmarshal_model_mapping_failed", http.StatusInternalServerError)
-		}
-		if modelMap[imageModel] != "" {
-			imageModel = modelMap[imageModel]
-			isModelMapped = true
-		}
-	}
-	baseURL := common.ChannelBaseURLs[channelType]
-	requestURL := c.Request.URL.String()
-	if c.GetString("base_url") != "" {
-		baseURL = c.GetString("base_url")
-	}
-	fullRequestURL := getFullRequestURL(baseURL, requestURL, channelType)
-	if channelType == common.ChannelTypeAzure {
-		// https://learn.microsoft.com/en-us/azure/ai-services/openai/dall-e-quickstart?tabs=dalle3%2Ccommand-line&pivots=rest-api
-		apiVersion := GetAPIVersion(c)
-		// https://{resource_name}.openai.azure.com/openai/deployments/dall-e-3/images/generations?api-version=2023-06-01-preview
-		fullRequestURL = fmt.Sprintf("%s/openai/deployments/%s/images/generations?api-version=%s", baseURL, imageModel, apiVersion)
-	}
-
-	var requestBody io.Reader
-	if isModelMapped || channelType == common.ChannelTypeAzure { // make Azure channel request body
-		jsonStr, err := json.Marshal(imageRequest)
-		if err != nil {
-			return errorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
-		}
-		requestBody = bytes.NewBuffer(jsonStr)
-	} else {
-		requestBody = c.Request.Body
-	}
-
-	modelRatio := common.GetModelRatio(imageModel)
-	groupRatio := common.GetGroupRatio(group)
-	ratio := modelRatio * groupRatio
-	userQuota, err := model.CacheGetUserQuota(userId)
-
-	quota := int(ratio*imageCostRatio*1000) * imageRequest.N
-
-	if userQuota-quota < 0 {
-		return errorWrapper(errors.New("user quota is not enough"), "insufficient_user_quota", http.StatusForbidden)
-	}
-
-	req, err := http.NewRequest(c.Request.Method, fullRequestURL, requestBody)
-	if err != nil {
-		return errorWrapper(err, "new_request_failed", http.StatusInternalServerError)
-	}
-	token := c.Request.Header.Get("Authorization")
-	if channelType == common.ChannelTypeAzure { // Azure authentication
-		token = strings.TrimPrefix(token, "Bearer ")
-		req.Header.Set("api-key", token)
-	} else {
-		req.Header.Set("Authorization", token)
-	}
-
-	req.Header.Set("Content-Type", c.Request.Header.Get("Content-Type"))
-	req.Header.Set("Accept", c.Request.Header.Get("Accept"))
-
-	resp, err := httpClient.Do(req)
-	if err != nil {
-		return errorWrapper(err, "do_request_failed", http.StatusInternalServerError)
-	}
-
-	err = req.Body.Close()
-	if err != nil {
-		return errorWrapper(err, "close_request_body_failed", http.StatusInternalServerError)
-	}
-	err = c.Request.Body.Close()
-	if err != nil {
-		return errorWrapper(err, "close_request_body_failed", http.StatusInternalServerError)
-	}
-	var textResponse ImageResponse
-
-	defer func(ctx context.Context) {
-		if resp.StatusCode != http.StatusOK {
-			return
-		}
-		err := model.PostConsumeTokenQuota(tokenId, quota)
-		if err != nil {
-			common.SysError("error consuming token remain quota: " + err.Error())
-		}
-		err = model.CacheUpdateUserQuota(userId)
-		if err != nil {
-			common.SysError("error update user quota cache: " + err.Error())
-		}
-		if quota != 0 {
-			tokenName := c.GetString("token_name")
-			logContent := fmt.Sprintf("模型倍率 %.2f，分组倍率 %.2f", modelRatio, groupRatio)
-			model.RecordConsumeLog(ctx, userId, channelId, 0, 0, imageModel, tokenName, quota, logContent)
-			model.UpdateUserUsedQuotaAndRequestCount(userId, quota)
-			channelId := c.GetInt("channel_id")
-			model.UpdateChannelUsedQuota(channelId, quota)
-		}
-	}(c.Request.Context())
-
-	responseBody, err := io.ReadAll(resp.Body)
-
-	if err != nil {
-		return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError)
-	}
-	err = resp.Body.Close()
-	if err != nil {
-		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError)
-	}
-	err = json.Unmarshal(responseBody, &textResponse)
-	if err != nil {
-		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError)
-	}
-
-	resp.Body = io.NopCloser(bytes.NewBuffer(responseBody))
-
-	for k, v := range resp.Header {
-		c.Writer.Header().Set(k, v[0])
-	}
-	c.Writer.WriteHeader(resp.StatusCode)
-
-	_, err = io.Copy(c.Writer, resp.Body)
-	if err != nil {
-		return errorWrapper(err, "copy_response_body_failed", http.StatusInternalServerError)
-	}
-	err = resp.Body.Close()
-	if err != nil {
-		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError)
-	}
-	return nil
-}

controller/relay-openai.go

@@ -1,143 +0,0 @@
-package controller
-
-import (
-	"bufio"
-	"bytes"
-	"encoding/json"
-	"github.com/gin-gonic/gin"
-	"io"
-	"net/http"
-	"one-api/common"
-	"strings"
-)
-
-func openaiStreamHandler(c *gin.Context, resp *http.Response, relayMode int) (*OpenAIErrorWithStatusCode, string) {
-	responseText := ""
-	scanner := bufio.NewScanner(resp.Body)
-	scanner.Split(func(data []byte, atEOF bool) (advance int, token []byte, err error) {
-		if atEOF && len(data) == 0 {
-			return 0, nil, nil
-		}
-		if i := strings.Index(string(data), "\n"); i >= 0 {
-			return i + 1, data[0:i], nil
-		}
-		if atEOF {
-			return len(data), data, nil
-		}
-		return 0, nil, nil
-	})
-	dataChan := make(chan string)
-	stopChan := make(chan bool)
-	go func() {
-		for scanner.Scan() {
-			data := scanner.Text()
-			if len(data) < 6 { // ignore blank line or wrong format
-				continue
-			}
-			if data[:6] != "data: " && data[:6] != "[DONE]" {
-				continue
-			}
-			dataChan <- data
-			data = data[6:]
-			if !strings.HasPrefix(data, "[DONE]") {
-				switch relayMode {
-				case RelayModeChatCompletions:
-					var streamResponse ChatCompletionsStreamResponse
-					err := json.Unmarshal([]byte(data), &streamResponse)
-					if err != nil {
-						common.SysError("error unmarshalling stream response: " + err.Error())
-						continue // just ignore the error
-					}
-					for _, choice := range streamResponse.Choices {
-						responseText += choice.Delta.Content
-					}
-				case RelayModeCompletions:
-					var streamResponse CompletionsStreamResponse
-					err := json.Unmarshal([]byte(data), &streamResponse)
-					if err != nil {
-						common.SysError("error unmarshalling stream response: " + err.Error())
-						continue
-					}
-					for _, choice := range streamResponse.Choices {
-						responseText += choice.Text
-					}
-				}
-			}
-		}
-		stopChan <- true
-	}()
-	setEventStreamHeaders(c)
-	c.Stream(func(w io.Writer) bool {
-		select {
-		case data := <-dataChan:
-			if strings.HasPrefix(data, "data: [DONE]") {
-				data = data[:12]
-			}
-			// some implementations may add \r at the end of data
-			data = strings.TrimSuffix(data, "\r")
-			c.Render(-1, common.CustomEvent{Data: data})
-			return true
-		case <-stopChan:
-			return false
-		}
-	})
-	err := resp.Body.Close()
-	if err != nil {
-		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), ""
-	}
-	return nil, responseText
-}
-
-func openaiHandler(c *gin.Context, resp *http.Response, promptTokens int, model string) (*OpenAIErrorWithStatusCode, *Usage) {
-	var textResponse TextResponse
-	responseBody, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
-	}
-	err = resp.Body.Close()
-	if err != nil {
-		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
-	}
-	err = json.Unmarshal(responseBody, &textResponse)
-	if err != nil {
-		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
-	}
-	if textResponse.Error.Type != "" {
-		return &OpenAIErrorWithStatusCode{
-			OpenAIError: textResponse.Error,
-			StatusCode:  resp.StatusCode,
-		}, nil
-	}
-	// Reset response body
-	resp.Body = io.NopCloser(bytes.NewBuffer(responseBody))
-
-	// We shouldn't set the header before we parse the response body, because the parse part may fail.
-	// And then we will have to send an error response, but in this case, the header has already been set.
-	// So the httpClient will be confused by the response.
-	// For example, Postman will report error, and we cannot check the response at all.
-	for k, v := range resp.Header {
-		c.Writer.Header().Set(k, v[0])
-	}
-	c.Writer.WriteHeader(resp.StatusCode)
-	_, err = io.Copy(c.Writer, resp.Body)
-	if err != nil {
-		return errorWrapper(err, "copy_response_body_failed", http.StatusInternalServerError), nil
-	}
-	err = resp.Body.Close()
-	if err != nil {
-		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
-	}
-
-	if textResponse.Usage.TotalTokens == 0 {
-		completionTokens := 0
-		for _, choice := range textResponse.Choices {
-			completionTokens += countTokenText(choice.Message.StringContent(), model)
-		}
-		textResponse.Usage = Usage{
-			PromptTokens:     promptTokens,
-			CompletionTokens: completionTokens,
-			TotalTokens:      promptTokens + completionTokens,
-		}
-	}
-	return nil, &textResponse.Usage
-}

controller/relay-palm.go

@@ -1,206 +0,0 @@
-package controller
-
-import (
-	"encoding/json"
-	"fmt"
-	"github.com/gin-gonic/gin"
-	"io"
-	"net/http"
-	"one-api/common"
-)
-
-// https://developers.generativeai.google/api/rest/generativelanguage/models/generateMessage#request-body
-// https://developers.generativeai.google/api/rest/generativelanguage/models/generateMessage#response-body
-
-type PaLMChatMessage struct {
-	Author  string `json:"author"`
-	Content string `json:"content"`
-}
-
-type PaLMFilter struct {
-	Reason  string `json:"reason"`
-	Message string `json:"message"`
-}
-
-type PaLMPrompt struct {
-	Messages []PaLMChatMessage `json:"messages"`
-}
-
-type PaLMChatRequest struct {
-	Prompt         PaLMPrompt `json:"prompt"`
-	Temperature    float64    `json:"temperature,omitempty"`
-	CandidateCount int        `json:"candidateCount,omitempty"`
-	TopP           float64    `json:"topP,omitempty"`
-	TopK           int        `json:"topK,omitempty"`
-}
-
-type PaLMError struct {
-	Code    int    `json:"code"`
-	Message string `json:"message"`
-	Status  string `json:"status"`
-}
-
-type PaLMChatResponse struct {
-	Candidates []PaLMChatMessage `json:"candidates"`
-	Messages   []Message         `json:"messages"`
-	Filters    []PaLMFilter      `json:"filters"`
-	Error      PaLMError         `json:"error"`
-}
-
-func requestOpenAI2PaLM(textRequest GeneralOpenAIRequest) *PaLMChatRequest {
-	palmRequest := PaLMChatRequest{
-		Prompt: PaLMPrompt{
-			Messages: make([]PaLMChatMessage, 0, len(textRequest.Messages)),
-		},
-		Temperature:    textRequest.Temperature,
-		CandidateCount: textRequest.N,
-		TopP:           textRequest.TopP,
-		TopK:           textRequest.MaxTokens,
-	}
-	for _, message := range textRequest.Messages {
-		palmMessage := PaLMChatMessage{
-			Content: message.StringContent(),
-		}
-		if message.Role == "user" {
-			palmMessage.Author = "0"
-		} else {
-			palmMessage.Author = "1"
-		}
-		palmRequest.Prompt.Messages = append(palmRequest.Prompt.Messages, palmMessage)
-	}
-	return &palmRequest
-}
-
-func responsePaLM2OpenAI(response *PaLMChatResponse) *OpenAITextResponse {
-	fullTextResponse := OpenAITextResponse{
-		Choices: make([]OpenAITextResponseChoice, 0, len(response.Candidates)),
-	}
-	for i, candidate := range response.Candidates {
-		choice := OpenAITextResponseChoice{
-			Index: i,
-			Message: Message{
-				Role:    "assistant",
-				Content: candidate.Content,
-			},
-			FinishReason: "stop",
-		}
-		fullTextResponse.Choices = append(fullTextResponse.Choices, choice)
-	}
-	return &fullTextResponse
-}
-
-func streamResponsePaLM2OpenAI(palmResponse *PaLMChatResponse) *ChatCompletionsStreamResponse {
-	var choice ChatCompletionsStreamResponseChoice
-	if len(palmResponse.Candidates) > 0 {
-		choice.Delta.Content = palmResponse.Candidates[0].Content
-	}
-	choice.FinishReason = &stopFinishReason
-	var response ChatCompletionsStreamResponse
-	response.Object = "chat.completion.chunk"
-	response.Model = "palm2"
-	response.Choices = []ChatCompletionsStreamResponseChoice{choice}
-	return &response
-}
-
-func palmStreamHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, string) {
-	responseText := ""
-	responseId := fmt.Sprintf("chatcmpl-%s", common.GetUUID())
-	createdTime := common.GetTimestamp()
-	dataChan := make(chan string)
-	stopChan := make(chan bool)
-	go func() {
-		responseBody, err := io.ReadAll(resp.Body)
-		if err != nil {
-			common.SysError("error reading stream response: " + err.Error())
-			stopChan <- true
-			return
-		}
-		err = resp.Body.Close()
-		if err != nil {
-			common.SysError("error closing stream response: " + err.Error())
-			stopChan <- true
-			return
-		}
-		var palmResponse PaLMChatResponse
-		err = json.Unmarshal(responseBody, &palmResponse)
-		if err != nil {
-			common.SysError("error unmarshalling stream response: " + err.Error())
-			stopChan <- true
-			return
-		}
-		fullTextResponse := streamResponsePaLM2OpenAI(&palmResponse)
-		fullTextResponse.Id = responseId
-		fullTextResponse.Created = createdTime
-		if len(palmResponse.Candidates) > 0 {
-			responseText = palmResponse.Candidates[0].Content
-		}
-		jsonResponse, err := json.Marshal(fullTextResponse)
-		if err != nil {
-			common.SysError("error marshalling stream response: " + err.Error())
-			stopChan <- true
-			return
-		}
-		dataChan <- string(jsonResponse)
-		stopChan <- true
-	}()
-	setEventStreamHeaders(c)
-	c.Stream(func(w io.Writer) bool {
-		select {
-		case data := <-dataChan:
-			c.Render(-1, common.CustomEvent{Data: "data: " + data})
-			return true
-		case <-stopChan:
-			c.Render(-1, common.CustomEvent{Data: "data: [DONE]"})
-			return false
-		}
-	})
-	err := resp.Body.Close()
-	if err != nil {
-		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), ""
-	}
-	return nil, responseText
-}
-
-func palmHandler(c *gin.Context, resp *http.Response, promptTokens int, model string) (*OpenAIErrorWithStatusCode, *Usage) {
-	responseBody, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
-	}
-	err = resp.Body.Close()
-	if err != nil {
-		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
-	}
-	var palmResponse PaLMChatResponse
-	err = json.Unmarshal(responseBody, &palmResponse)
-	if err != nil {
-		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
-	}
-	if palmResponse.Error.Code != 0 || len(palmResponse.Candidates) == 0 {
-		return &OpenAIErrorWithStatusCode{
-			OpenAIError: OpenAIError{
-				Message: palmResponse.Error.Message,
-				Type:    palmResponse.Error.Status,
-				Param:   "",
-				Code:    palmResponse.Error.Code,
-			},
-			StatusCode: resp.StatusCode,
-		}, nil
-	}
-	fullTextResponse := responsePaLM2OpenAI(&palmResponse)
-	fullTextResponse.Model = model
-	completionTokens := countTokenText(palmResponse.Candidates[0].Content, model)
-	usage := Usage{
-		PromptTokens:     promptTokens,
-		CompletionTokens: completionTokens,
-		TotalTokens:      promptTokens + completionTokens,
-	}
-	fullTextResponse.Usage = usage
-	jsonResponse, err := json.Marshal(fullTextResponse)
-	if err != nil {
-		return errorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
-	}
-	c.Writer.Header().Set("Content-Type", "application/json")
-	c.Writer.WriteHeader(resp.StatusCode)
-	_, err = c.Writer.Write(jsonResponse)
-	return nil, &usage
-}

controller/relay-tencent.go

@@ -1,287 +0,0 @@
-package controller
-
-// import (
-// 	"bufio"
-// 	"crypto/hmac"
-// 	"crypto/sha1"
-// 	"encoding/base64"
-// 	"encoding/json"
-// 	"errors"
-// 	"fmt"
-// 	"github.com/gin-gonic/gin"
-// 	"io"
-// 	"net/http"
-// 	"one-api/common"
-// 	"sort"
-// 	"strconv"
-// 	"strings"
-// )
-
-// // https://cloud.tencent.com/document/product/1729/97732
-
-// type TencentMessage struct {
-// 	Role    string `json:"role"`
-// 	Content string `json:"content"`
-// }
-
-// type TencentChatRequest struct {
-// 	AppId    int64  `json:"app_id"`    // 腾讯云账号的 APPID
-// 	SecretId string `json:"secret_id"` // 官网 SecretId
-// 	// Timestamp当前 UNIX 时间戳，单位为秒，可记录发起 API 请求的时间。
-// 	// 例如1529223702，如果与当前时间相差过大，会引起签名过期错误
-// 	Timestamp int64 `json:"timestamp"`
-// 	// Expired 签名的有效期，是一个符合 UNIX Epoch 时间戳规范的数值，
-// 	// 单位为秒；Expired 必须大于 Timestamp 且 Expired-Timestamp 小于90天
-// 	Expired int64  `json:"expired"`
-// 	QueryID string `json:"query_id"` //请求 Id，用于问题排查
-// 	// Temperature 较高的数值会使输出更加随机，而较低的数值会使其更加集中和确定
-// 	// 默认 1.0，取值区间为[0.0,2.0]，非必要不建议使用,不合理的取值会影响效果
-// 	// 建议该参数和 top_p 只设置1个，不要同时更改 top_p
-// 	Temperature float64 `json:"temperature"`
-// 	// TopP 影响输出文本的多样性，取值越大，生成文本的多样性越强
-// 	// 默认1.0，取值区间为[0.0, 1.0]，非必要不建议使用, 不合理的取值会影响效果
-// 	// 建议该参数和 temperature 只设置1个，不要同时更改
-// 	TopP float64 `json:"top_p"`
-// 	// Stream 0：同步，1：流式 （默认，协议：SSE)
-// 	// 同步请求超时：60s，如果内容较长建议使用流式
-// 	Stream int `json:"stream"`
-// 	// Messages 会话内容, 长度最多为40, 按对话时间从旧到新在数组中排列
-// 	// 输入 content 总数最大支持 3000 token。
-// 	Messages []TencentMessage `json:"messages"`
-// }
-
-// type TencentError struct {
-// 	Code    int    `json:"code"`
-// 	Message string `json:"message"`
-// }
-
-// type TencentUsage struct {
-// 	InputTokens  int `json:"input_tokens"`
-// 	OutputTokens int `json:"output_tokens"`
-// 	TotalTokens  int `json:"total_tokens"`
-// }
-
-// type TencentResponseChoices struct {
-// 	FinishReason string         `json:"finish_reason,omitempty"` // 流式结束标志位，为 stop 则表示尾包
-// 	Messages     TencentMessage `json:"messages,omitempty"`      // 内容，同步模式返回内容，流模式为 null 输出 content 内容总数最多支持 1024token。
-// 	Delta        TencentMessage `json:"delta,omitempty"`         // 内容，流模式返回内容，同步模式为 null 输出 content 内容总数最多支持 1024token。
-// }
-
-// type TencentChatResponse struct {
-// 	Choices []TencentResponseChoices `json:"choices,omitempty"` // 结果
-// 	Created string                   `json:"created,omitempty"` // unix 时间戳的字符串
-// 	Id      string                   `json:"id,omitempty"`      // 会话 id
-// 	Usage   Usage                    `json:"usage,omitempty"`   // token 数量
-// 	Error   TencentError             `json:"error,omitempty"`   // 错误信息 注意：此字段可能返回 null，表示取不到有效值
-// 	Note    string                   `json:"note,omitempty"`    // 注释
-// 	ReqID   string                   `json:"req_id,omitempty"`  // 唯一请求 Id，每次请求都会返回。用于反馈接口入参
-// }
-
-// func requestOpenAI2Tencent(request GeneralOpenAIRequest) *TencentChatRequest {
-// 	messages := make([]TencentMessage, 0, len(request.Messages))
-// 	for i := 0; i < len(request.Messages); i++ {
-// 		message := request.Messages[i]
-// 		if message.Role == "system" {
-// 			messages = append(messages, TencentMessage{
-// 				Role:    "user",
-// 				Content: message.Content,
-// 			})
-// 			messages = append(messages, TencentMessage{
-// 				Role:    "assistant",
-// 				Content: "Okay",
-// 			})
-// 			continue
-// 		}
-// 		messages = append(messages, TencentMessage{
-// 			Content: message.Content,
-// 			Role:    message.Role,
-// 		})
-// 	}
-// 	stream := 0
-// 	if request.Stream {
-// 		stream = 1
-// 	}
-// 	return &TencentChatRequest{
-// 		Timestamp:   common.GetTimestamp(),
-// 		Expired:     common.GetTimestamp() + 24*60*60,
-// 		QueryID:     common.GetUUID(),
-// 		Temperature: request.Temperature,
-// 		TopP:        request.TopP,
-// 		Stream:      stream,
-// 		Messages:    messages,
-// 	}
-// }
-
-// func responseTencent2OpenAI(response *TencentChatResponse) *OpenAITextResponse {
-// 	fullTextResponse := OpenAITextResponse{
-// 		Object:  "chat.completion",
-// 		Created: common.GetTimestamp(),
-// 		Usage:   response.Usage,
-// 	}
-// 	if len(response.Choices) > 0 {
-// 		choice := OpenAITextResponseChoice{
-// 			Index: 0,
-// 			Message: Message{
-// 				Role:    "assistant",
-// 				Content: response.Choices[0].Messages.Content,
-// 			},
-// 			FinishReason: response.Choices[0].FinishReason,
-// 		}
-// 		fullTextResponse.Choices = append(fullTextResponse.Choices, choice)
-// 	}
-// 	return &fullTextResponse
-// }
-
-// func streamResponseTencent2OpenAI(TencentResponse *TencentChatResponse) *ChatCompletionsStreamResponse {
-// 	response := ChatCompletionsStreamResponse{
-// 		Object:  "chat.completion.chunk",
-// 		Created: common.GetTimestamp(),
-// 		Model:   "tencent-hunyuan",
-// 	}
-// 	if len(TencentResponse.Choices) > 0 {
-// 		var choice ChatCompletionsStreamResponseChoice
-// 		choice.Delta.Content = TencentResponse.Choices[0].Delta.Content
-// 		if TencentResponse.Choices[0].FinishReason == "stop" {
-// 			choice.FinishReason = &stopFinishReason
-// 		}
-// 		response.Choices = append(response.Choices, choice)
-// 	}
-// 	return &response
-// }
-
-// func tencentStreamHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, string) {
-// 	var responseText string
-// 	scanner := bufio.NewScanner(resp.Body)
-// 	scanner.Split(func(data []byte, atEOF bool) (advance int, token []byte, err error) {
-// 		if atEOF && len(data) == 0 {
-// 			return 0, nil, nil
-// 		}
-// 		if i := strings.Index(string(data), "\n"); i >= 0 {
-// 			return i + 1, data[0:i], nil
-// 		}
-// 		if atEOF {
-// 			return len(data), data, nil
-// 		}
-// 		return 0, nil, nil
-// 	})
-// 	dataChan := make(chan string)
-// 	stopChan := make(chan bool)
-// 	go func() {
-// 		for scanner.Scan() {
-// 			data := scanner.Text()
-// 			if len(data) < 5 { // ignore blank line or wrong format
-// 				continue
-// 			}
-// 			if data[:5] != "data:" {
-// 				continue
-// 			}
-// 			data = data[5:]
-// 			dataChan <- data
-// 		}
-// 		stopChan <- true
-// 	}()
-// 	setEventStreamHeaders(c)
-// 	c.Stream(func(w io.Writer) bool {
-// 		select {
-// 		case data := <-dataChan:
-// 			var TencentResponse TencentChatResponse
-// 			err := json.Unmarshal([]byte(data), &TencentResponse)
-// 			if err != nil {
-// 				common.SysError("error unmarshalling stream response: " + err.Error())
-// 				return true
-// 			}
-// 			response := streamResponseTencent2OpenAI(&TencentResponse)
-// 			if len(response.Choices) != 0 {
-// 				responseText += response.Choices[0].Delta.Content
-// 			}
-// 			jsonResponse, err := json.Marshal(response)
-// 			if err != nil {
-// 				common.SysError("error marshalling stream response: " + err.Error())
-// 				return true
-// 			}
-// 			c.Render(-1, common.CustomEvent{Data: "data: " + string(jsonResponse)})
-// 			return true
-// 		case <-stopChan:
-// 			c.Render(-1, common.CustomEvent{Data: "data: [DONE]"})
-// 			return false
-// 		}
-// 	})
-// 	err := resp.Body.Close()
-// 	if err != nil {
-// 		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), ""
-// 	}
-// 	return nil, responseText
-// }
-
-// func tencentHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, *Usage) {
-// 	var TencentResponse TencentChatResponse
-// 	responseBody, err := io.ReadAll(resp.Body)
-// 	if err != nil {
-// 		return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	err = resp.Body.Close()
-// 	if err != nil {
-// 		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	err = json.Unmarshal(responseBody, &TencentResponse)
-// 	if err != nil {
-// 		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	if TencentResponse.Error.Code != 0 {
-// 		return &OpenAIErrorWithStatusCode{
-// 			OpenAIError: OpenAIError{
-// 				Message: TencentResponse.Error.Message,
-// 				Code:    TencentResponse.Error.Code,
-// 			},
-// 			StatusCode: resp.StatusCode,
-// 		}, nil
-// 	}
-// 	fullTextResponse := responseTencent2OpenAI(&TencentResponse)
-// 	jsonResponse, err := json.Marshal(fullTextResponse)
-// 	if err != nil {
-// 		return errorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	c.Writer.Header().Set("Content-Type", "application/json")
-// 	c.Writer.WriteHeader(resp.StatusCode)
-// 	_, err = c.Writer.Write(jsonResponse)
-// 	return nil, &fullTextResponse.Usage
-// }
-
-// func parseTencentConfig(config string) (appId int64, secretId string, secretKey string, err error) {
-// 	parts := strings.Split(config, "|")
-// 	if len(parts) != 3 {
-// 		err = errors.New("invalid tencent config")
-// 		return
-// 	}
-// 	appId, err = strconv.ParseInt(parts[0], 10, 64)
-// 	secretId = parts[1]
-// 	secretKey = parts[2]
-// 	return
-// }
-
-// func getTencentSign(req TencentChatRequest, secretKey string) string {
-// 	params := make([]string, 0)
-// 	params = append(params, "app_id="+strconv.FormatInt(req.AppId, 10))
-// 	params = append(params, "secret_id="+req.SecretId)
-// 	params = append(params, "timestamp="+strconv.FormatInt(req.Timestamp, 10))
-// 	params = append(params, "query_id="+req.QueryID)
-// 	params = append(params, "temperature="+strconv.FormatFloat(req.Temperature, 'f', -1, 64))
-// 	params = append(params, "top_p="+strconv.FormatFloat(req.TopP, 'f', -1, 64))
-// 	params = append(params, "stream="+strconv.Itoa(req.Stream))
-// 	params = append(params, "expired="+strconv.FormatInt(req.Expired, 10))
-
-// 	var messageStr string
-// 	for _, msg := range req.Messages {
-// 		messageStr += fmt.Sprintf(`{"role":"%s","content":"%s"},`, msg.Role, msg.Content)
-// 	}
-// 	messageStr = strings.TrimSuffix(messageStr, ",")
-// 	params = append(params, "messages=["+messageStr+"]")
-
-// 	sort.Sort(sort.StringSlice(params))
-// 	url := "hunyuan.cloud.tencent.com/hyllm/v1/chat/completions?" + strings.Join(params, "&")
-// 	mac := hmac.New(sha1.New, []byte(secretKey))
-// 	signURL := url
-// 	mac.Write([]byte(signURL))
-// 	sign := mac.Sum([]byte(nil))
-// 	return base64.StdEncoding.EncodeToString(sign)
-// }

controller/relay-text.go

@@ -1,759 +0,0 @@
-package controller
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"math"
-	"net/http"
-	"one-api/common"
-	"one-api/model"
-	"os"
-	"strings"
-	"time"
-
-	"github.com/gin-gonic/gin"
-)
-
-const (
-	APITypeOpenAI = iota
-	APITypeClaude
-	APITypePaLM
-	APITypeBaidu
-	APITypeZhipu
-	APITypeAli
-	APITypeXunfei
-	APITypeAIProxyLibrary
-	APITypeTencent
-	APITypeGemini
-)
-
-var httpClient *http.Client
-var impatientHTTPClient *http.Client
-
-func init() {
-	if common.RelayTimeout == 0 {
-		httpClient = &http.Client{}
-	} else {
-		httpClient = &http.Client{
-			Timeout: time.Duration(common.RelayTimeout) * time.Second,
-		}
-	}
-
-	impatientHTTPClient = &http.Client{
-		Timeout: 5 * time.Second,
-	}
-}
-
-func relayTextHelper(c *gin.Context, relayMode int) *OpenAIErrorWithStatusCode {
-	channelType := c.GetInt("channel")
-	channelId := c.GetInt("channel_id")
-	tokenId := c.GetInt("token_id")
-	userId := c.GetInt("id")
-	group := c.GetString("group")
-	var textRequest GeneralOpenAIRequest
-	err := common.UnmarshalBodyReusable(c, &textRequest)
-	if err != nil {
-		return errorWrapper(err, "bind_request_body_failed", http.StatusBadRequest)
-	}
-	if textRequest.MaxTokens < 0 || textRequest.MaxTokens > math.MaxInt32/2 {
-		return errorWrapper(errors.New("max_tokens is invalid"), "invalid_max_tokens", http.StatusBadRequest)
-	}
-	if relayMode == RelayModeModerations && textRequest.Model == "" {
-		textRequest.Model = "text-moderation-latest"
-	}
-	if relayMode == RelayModeEmbeddings && textRequest.Model == "" {
-		textRequest.Model = c.Param("model")
-	}
-	// request validation
-	if textRequest.Model == "" {
-		return errorWrapper(errors.New("model is required"), "required_field_missing", http.StatusBadRequest)
-	}
-	switch relayMode {
-	case RelayModeCompletions:
-		if textRequest.Prompt == "" {
-			return errorWrapper(errors.New("field prompt is required"), "required_field_missing", http.StatusBadRequest)
-		}
-	case RelayModeChatCompletions:
-		if textRequest.Messages == nil || len(textRequest.Messages) == 0 {
-			return errorWrapper(errors.New("field messages is required"), "required_field_missing", http.StatusBadRequest)
-		}
-	case RelayModeEmbeddings:
-	case RelayModeModerations:
-		if textRequest.Input == "" {
-			return errorWrapper(errors.New("field input is required"), "required_field_missing", http.StatusBadRequest)
-		}
-	case RelayModeEdits:
-		if textRequest.Instruction == "" {
-			return errorWrapper(errors.New("field instruction is required"), "required_field_missing", http.StatusBadRequest)
-		}
-	}
-	// map model name
-	modelMapping := c.GetString("model_mapping")
-	isModelMapped := false
-	if modelMapping != "" && modelMapping != "{}" {
-		modelMap := make(map[string]string)
-		err := json.Unmarshal([]byte(modelMapping), &modelMap)
-		if err != nil {
-			return errorWrapper(err, "unmarshal_model_mapping_failed", http.StatusInternalServerError)
-		}
-		if modelMap[textRequest.Model] != "" {
-			textRequest.Model = modelMap[textRequest.Model]
-			isModelMapped = true
-		}
-	}
-	apiType := APITypeOpenAI
-	switch channelType {
-	case common.ChannelTypeAnthropic:
-		apiType = APITypeClaude
-	case common.ChannelTypeBaidu:
-		apiType = APITypeBaidu
-	case common.ChannelTypePaLM:
-		apiType = APITypePaLM
-	case common.ChannelTypeZhipu:
-		apiType = APITypeZhipu
-	case common.ChannelTypeAli:
-		apiType = APITypeAli
-	case common.ChannelTypeXunfei:
-		apiType = APITypeXunfei
-	case common.ChannelTypeAIProxyLibrary:
-		apiType = APITypeAIProxyLibrary
-	case common.ChannelTypeTencent:
-		apiType = APITypeTencent
-	case common.ChannelTypeGemini:
-		apiType = APITypeGemini
-	}
-	baseURL := common.ChannelBaseURLs[channelType]
-	requestURL := c.Request.URL.String()
-	if c.GetString("base_url") != "" {
-		baseURL = c.GetString("base_url")
-	}
-	fullRequestURL := getFullRequestURL(baseURL, requestURL, channelType)
-	switch apiType {
-	case APITypeOpenAI:
-		if channelType == common.ChannelTypeAzure {
-			// https://learn.microsoft.com/en-us/azure/cognitive-services/openai/chatgpt-quickstart?pivots=rest-api&tabs=command-line#rest-api
-			apiVersion := GetAPIVersion(c)
-			requestURL := strings.Split(requestURL, "?")[0]
-			requestURL = fmt.Sprintf("%s?api-version=%s", requestURL, apiVersion)
-			baseURL = c.GetString("base_url")
-			task := strings.TrimPrefix(requestURL, "/v1/")
-			model_ := textRequest.Model
-			model_ = strings.Replace(model_, ".", "", -1)
-			// https://github.com/songquanpeng/one-api/issues/67
-			model_ = strings.TrimSuffix(model_, "-0301")
-			model_ = strings.TrimSuffix(model_, "-0314")
-			model_ = strings.TrimSuffix(model_, "-0613")
-
-			requestURL = fmt.Sprintf("/openai/deployments/%s/%s", model_, task)
-			fullRequestURL = getFullRequestURL(baseURL, requestURL, channelType)
-		}
-	case APITypeClaude:
-		fullRequestURL = "https://api.anthropic.com/v1/complete"
-		if baseURL != "" {
-			fullRequestURL = fmt.Sprintf("%s/v1/complete", baseURL)
-		}
-	// case APITypeBaidu:
-	// 	switch textRequest.Model {
-	// 	case "ERNIE-Bot":
-	// 		fullRequestURL = "https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/completions"
-	// 	case "ERNIE-Bot-turbo":
-	// 		fullRequestURL = "https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/eb-instant"
-	// 	case "ERNIE-Bot-4":
-	// 		fullRequestURL = "https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/completions_pro"
-	// 	case "BLOOMZ-7B":
-	// 		fullRequestURL = "https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/bloomz_7b1"
-	// 	case "Embedding-V1":
-	// 		fullRequestURL = "https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/embeddings/embedding-v1"
-	// 	}
-	// 	apiKey := c.Request.Header.Get("Authorization")
-	// 	apiKey = strings.TrimPrefix(apiKey, "Bearer ")
-	// 	var err error
-	// 	if apiKey, err = getBaiduAccessToken(apiKey); err != nil {
-	// 		return errorWrapper(err, "invalid_baidu_config", http.StatusInternalServerError)
-	// 	}
-	// 	fullRequestURL += "?access_token=" + apiKey
-	case APITypePaLM:
-		fullRequestURL = "https://generativelanguage.googleapis.com/v1beta2/models/chat-bison-001:generateMessage"
-		if baseURL != "" {
-			fullRequestURL = fmt.Sprintf("%s/v1beta2/models/chat-bison-001:generateMessage", baseURL)
-		}
-	case APITypeGemini:
-		requestBaseURL := "https://generativelanguage.googleapis.com"
-		if baseURL != "" {
-			requestBaseURL = baseURL
-		}
-		version := "v1"
-		if c.GetString("api_version") != "" {
-			version = c.GetString("api_version")
-		}
-		action := "generateContent"
-		if textRequest.Stream {
-			action = "streamGenerateContent"
-		}
-		fullRequestURL = fmt.Sprintf("%s/%s/models/%s:%s", requestBaseURL, version, textRequest.Model, action)
-	case APITypeZhipu:
-		method := "invoke"
-		if textRequest.Stream {
-			method = "sse-invoke"
-		}
-		fullRequestURL = fmt.Sprintf("https://open.bigmodel.cn/api/paas/v3/model-api/%s/%s", textRequest.Model, method)
-	case APITypeAli:
-		fullRequestURL = "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation"
-		if relayMode == RelayModeEmbeddings {
-			fullRequestURL = "https://dashscope.aliyuncs.com/api/v1/services/embeddings/text-embedding/text-embedding"
-		}
-	case APITypeTencent:
-		fullRequestURL = "https://hunyuan.cloud.tencent.com/hyllm/v1/chat/completions"
-	case APITypeAIProxyLibrary:
-		fullRequestURL = fmt.Sprintf("%s/api/library/ask", baseURL)
-	}
-	var promptTokens int
-	var completionTokens int
-	switch relayMode {
-	case RelayModeChatCompletions:
-		promptTokens = countTokenMessages(textRequest.Messages, textRequest.Model)
-	case RelayModeCompletions:
-		promptTokens = countTokenInput(textRequest.Prompt, textRequest.Model)
-	case RelayModeModerations:
-		promptTokens = countTokenInput(textRequest.Input, textRequest.Model)
-	}
-	preConsumedTokens := common.PreConsumedQuota
-	if textRequest.MaxTokens != 0 {
-		preConsumedTokens = promptTokens + textRequest.MaxTokens
-	}
-	modelRatio := common.GetModelRatio(textRequest.Model)
-	groupRatio := common.GetGroupRatio(group)
-	ratio := modelRatio * groupRatio
-	preConsumedQuota := int(float64(preConsumedTokens) * ratio)
-	userQuota, err := model.CacheGetUserQuota(userId)
-	if err != nil {
-		return errorWrapper(err, "get_user_quota_failed", http.StatusInternalServerError)
-	}
-	if userQuota-preConsumedQuota < 0 {
-		return errorWrapper(errors.New("user quota is not enough"), "insufficient_user_quota", http.StatusForbidden)
-	}
-	err = model.CacheDecreaseUserQuota(userId, preConsumedQuota)
-	if err != nil {
-		return errorWrapper(err, "decrease_user_quota_failed", http.StatusInternalServerError)
-	}
-	if userQuota > 100*preConsumedQuota {
-		// in this case, we do not pre-consume quota
-		// because the user has enough quota
-		preConsumedQuota = 0
-		common.LogInfo(c.Request.Context(), fmt.Sprintf("user %d has enough quota %d, trusted and no need to pre-consume", userId, userQuota))
-	}
-	if preConsumedQuota > 0 {
-		err := model.PreConsumeTokenQuota(tokenId, preConsumedQuota)
-		if err != nil {
-			return errorWrapper(err, "pre_consume_token_quota_failed", http.StatusForbidden)
-		}
-	}
-	var requestBody io.Reader
-	if isModelMapped {
-		jsonStr, err := json.Marshal(textRequest)
-		if err != nil {
-			return errorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
-		}
-		requestBody = bytes.NewBuffer(jsonStr)
-	} else {
-		requestBody = c.Request.Body
-	}
-
-	common.LogInfo(c.Request.Context(), fmt.Sprintf(
-		"convert to apitype %d, channel_type %d, channel_id %d",
-		apiType, channelType, channelId))
-	switch apiType {
-	case APITypeClaude:
-		claudeRequest := requestOpenAI2Claude(textRequest)
-		jsonStr, err := json.Marshal(claudeRequest)
-		if err != nil {
-			return errorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
-		}
-		requestBody = bytes.NewBuffer(jsonStr)
-	// case APITypeBaidu:
-	// 	var jsonData []byte
-	// 	var err error
-	// 	switch relayMode {
-	// 	case RelayModeEmbeddings:
-	// 		baiduEmbeddingRequest := embeddingRequestOpenAI2Baidu(textRequest)
-	// 		jsonData, err = json.Marshal(baiduEmbeddingRequest)
-	// 	default:
-	// 		baiduRequest := requestOpenAI2Baidu(textRequest)
-	// 		jsonData, err = json.Marshal(baiduRequest)
-	// 	}
-	// 	if err != nil {
-	// 		return errorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
-	// 	}
-	// 	requestBody = bytes.NewBuffer(jsonData)
-	case APITypePaLM:
-		palmRequest := requestOpenAI2PaLM(textRequest)
-		jsonStr, err := json.Marshal(palmRequest)
-		if err != nil {
-			return errorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
-		}
-		requestBody = bytes.NewBuffer(jsonStr)
-	case APITypeGemini:
-		geminiChatRequest := requestOpenAI2Gemini(textRequest)
-		jsonStr, err := json.Marshal(geminiChatRequest)
-		if err != nil {
-			return errorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
-		}
-		requestBody = bytes.NewBuffer(jsonStr)
-		fmt.Println(">> convert request body to gemini: " + string(jsonStr)) // FIXME
-	// case APITypeZhipu:
-	// 	zhipuRequest := requestOpenAI2Zhipu(textRequest)
-	// 	jsonStr, err := json.Marshal(zhipuRequest)
-	// 	if err != nil {
-	// 		return errorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
-	// 	}
-	// 	requestBody = bytes.NewBuffer(jsonStr)
-	// case APITypeAli:
-	// 	var jsonStr []byte
-	// 	var err error
-	// 	switch relayMode {
-	// 	case RelayModeEmbeddings:
-	// 		aliEmbeddingRequest := embeddingRequestOpenAI2Ali(textRequest)
-	// 		jsonStr, err = json.Marshal(aliEmbeddingRequest)
-	// 	default:
-	// 		aliRequest := requestOpenAI2Ali(textRequest)
-	// 		jsonStr, err = json.Marshal(aliRequest)
-	// 	}
-	// 	if err != nil {
-	// 		return errorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
-	// 	}
-	// 	requestBody = bytes.NewBuffer(jsonStr)
-	// case APITypeTencent:
-	// 	apiKey := c.Request.Header.Get("Authorization")
-	// 	apiKey = strings.TrimPrefix(apiKey, "Bearer ")
-	// 	appId, secretId, secretKey, err := parseTencentConfig(apiKey)
-	// 	if err != nil {
-	// 		return errorWrapper(err, "invalid_tencent_config", http.StatusInternalServerError)
-	// 	}
-	// 	tencentRequest := requestOpenAI2Tencent(textRequest)
-	// 	tencentRequest.AppId = appId
-	// 	tencentRequest.SecretId = secretId
-	// 	jsonStr, err := json.Marshal(tencentRequest)
-	// 	if err != nil {
-	// 		return errorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
-	// 	}
-	// 	sign := getTencentSign(*tencentRequest, secretKey)
-	// 	c.Request.Header.Set("Authorization", sign)
-	// 	requestBody = bytes.NewBuffer(jsonStr)
-	case APITypeAIProxyLibrary:
-		aiProxyLibraryRequest := requestOpenAI2AIProxyLibrary(textRequest)
-		aiProxyLibraryRequest.LibraryId = c.GetString("library_id")
-		jsonStr, err := json.Marshal(aiProxyLibraryRequest)
-		if err != nil {
-			return errorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
-		}
-		requestBody = bytes.NewBuffer(jsonStr)
-	}
-
-	var req *http.Request
-	var resp *http.Response
-	isStream := textRequest.Stream
-
-	if apiType != APITypeXunfei { // cause xunfei use websocket
-		req, err = http.NewRequest(c.Request.Method, fullRequestURL, requestBody)
-		if err != nil {
-			return errorWrapper(err, "new_request_failed", http.StatusInternalServerError)
-		}
-		apiKey := c.Request.Header.Get("Authorization")
-		apiKey = strings.TrimPrefix(apiKey, "Bearer ")
-
-		switch apiType {
-		case APITypeOpenAI:
-			if channelType == common.ChannelTypeAzure {
-				req.Header.Set("api-key", apiKey)
-			} else {
-				req.Header.Set("Authorization", c.Request.Header.Get("Authorization"))
-				if channelType == common.ChannelTypeOpenRouter {
-					req.Header.Set("HTTP-Referer", "https://github.com/songquanpeng/one-api")
-					req.Header.Set("X-Title", "One API")
-				}
-			}
-		case APITypeClaude:
-			req.Header.Set("x-api-key", apiKey)
-			anthropicVersion := c.Request.Header.Get("anthropic-version")
-			if anthropicVersion == "" {
-				anthropicVersion = "2023-06-01"
-			}
-			req.Header.Set("anthropic-version", anthropicVersion)
-		// case APITypeZhipu:
-		// 	token := getZhipuToken(apiKey)
-		// 	req.Header.Set("Authorization", token)
-		// case APITypeAli:
-		// 	req.Header.Set("Authorization", "Bearer "+apiKey)
-		// 	if textRequest.Stream {
-		// 		req.Header.Set("X-DashScope-SSE", "enable")
-		// 	}
-		// 	if c.GetString("plugin") != "" {
-		// 		req.Header.Set("X-DashScope-Plugin", c.GetString("plugin"))
-		// 	}
-		// case APITypeTencent:
-		// 	req.Header.Set("Authorization", apiKey)
-		case APITypePaLM:
-			req.Header.Set("x-goog-api-key", apiKey)
-		case APITypeGemini:
-			req.Header.Set("x-goog-api-key", apiKey)
-		default:
-			req.Header.Set("Authorization", "Bearer "+apiKey)
-		}
-		req.Header.Set("Content-Type", c.Request.Header.Get("Content-Type"))
-		req.Header.Set("Accept", c.Request.Header.Get("Accept"))
-		if isStream && c.Request.Header.Get("Accept") == "" {
-			req.Header.Set("Accept", "text/event-stream")
-		}
-		//req.Header.Set("Connection", c.Request.Header.Get("Connection"))
-		resp, err = httpClient.Do(req)
-		if err != nil {
-			return errorWrapper(err, "do_request_failed", http.StatusInternalServerError)
-		}
-		err = req.Body.Close()
-		if err != nil {
-			return errorWrapper(err, "close_request_body_failed", http.StatusInternalServerError)
-		}
-		err = c.Request.Body.Close()
-		if err != nil {
-			return errorWrapper(err, "close_request_body_failed", http.StatusInternalServerError)
-		}
-		isStream = isStream || strings.HasPrefix(resp.Header.Get("Content-Type"), "text/event-stream")
-
-		if resp.StatusCode != http.StatusOK {
-			if preConsumedQuota != 0 {
-				go func(ctx context.Context) {
-					// return pre-consumed quota
-					err := model.PostConsumeTokenQuota(tokenId, -preConsumedQuota)
-					if err != nil {
-						common.LogError(ctx, "error return pre-consumed quota: "+err.Error())
-					}
-				}(c.Request.Context())
-			}
-
-			{ // more error info
-				if reqdata, err := json.Marshal(req.Body); err != nil {
-					fmt.Printf("[ERROR] marshal relay text error: %s\n", err.Error())
-				} else {
-					if respdata, err := io.ReadAll(resp.Body); err != nil {
-						fmt.Printf("[ERROR] read resp body error: %s\n", err.Error())
-					} else {
-						resp.Body = io.NopCloser(bytes.NewBuffer(respdata))
-
-						fmt.Printf("[ERROR] send req %q to %s got error [%d]%s\n",
-							string(reqdata), req.URL.String(), resp.StatusCode, string(respdata))
-					}
-				}
-			}
-
-			return relayErrorHandler(resp)
-		}
-	}
-
-	var textResponse TextResponse
-	tokenName := c.GetString("token_name")
-
-	defer func(ctx context.Context) {
-		// c.Writer.Flush()
-		go func() {
-			quota := 0
-			completionRatio := common.GetCompletionRatio(textRequest.Model)
-			promptTokens = textResponse.Usage.PromptTokens
-			completionTokens = textResponse.Usage.CompletionTokens
-			quota = int(math.Ceil((float64(promptTokens) + float64(completionTokens)*completionRatio) * ratio))
-			if ratio != 0 && quota <= 0 {
-				quota = 1
-			}
-			totalTokens := promptTokens + completionTokens
-			if totalTokens == 0 {
-				// in this case, must be some error happened
-				// we cannot just return, because we may have to return the pre-consumed quota
-				quota = 0
-			}
-			quotaDelta := quota - preConsumedQuota
-			err := model.PostConsumeTokenQuota(tokenId, quotaDelta)
-			if err != nil {
-				common.LogError(ctx, "error consuming token remain quota: "+err.Error())
-			}
-			err = model.CacheUpdateUserQuota(userId)
-			if err != nil {
-				common.LogError(ctx, "error update user quota cache: "+err.Error())
-			}
-			if quota != 0 {
-				logContent := fmt.Sprintf("模型倍率 %.2f，分组倍率 %.2f", modelRatio, groupRatio)
-				model.RecordConsumeLog(ctx, userId, channelId, promptTokens, completionTokens, textRequest.Model, tokenName, quota, logContent)
-				model.UpdateUserUsedQuotaAndRequestCount(userId, quota)
-				model.UpdateChannelUsedQuota(channelId, quota)
-			}
-
-			if os.Getenv("LLM_CONSERVATION_AUDIT") != "" &&
-				textRequest.Model != "" ||
-				textRequest.MaxTokens != 0 ||
-				len(textRequest.Messages) != 0 ||
-				textResponse.Content != "" {
-				go func() {
-					ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
-					defer cancel()
-
-					body, err := json.Marshal(map[string]any{
-						"model":      textRequest.Model,
-						"max_tokens": textRequest.MaxTokens,
-						"messages":   textRequest.Messages,
-						"response":   textResponse.Content,
-					})
-					if err != nil {
-						common.LogError(ctx, "error marshal conservation audit: "+err.Error())
-						return
-					}
-
-					req, err := http.NewRequestWithContext(ctx, http.MethodPost, os.Getenv("LLM_CONSERVATION_AUDIT"), bytes.NewBuffer(body))
-					if err != nil {
-						common.LogError(ctx, "error new request conservation audit: "+err.Error())
-						return
-					}
-
-					resp, err := http.DefaultClient.Do(req)
-					if err != nil {
-						common.LogError(ctx, "error do conservation audit: "+err.Error())
-						return
-					}
-					defer resp.Body.Close()
-					if resp.StatusCode != http.StatusOK {
-						respBody, err := io.ReadAll(resp.Body)
-						if err != nil {
-							common.LogError(ctx, "error conservation audit: "+err.Error())
-							return
-						}
-
-						common.LogError(ctx, fmt.Sprintf("error conservation audit: [%d]%s", resp.StatusCode, string(respBody)))
-					}
-				}()
-			}
-		}()
-	}(c.Request.Context())
-	switch apiType {
-	case APITypeOpenAI:
-		if isStream {
-			err, responseText := openaiStreamHandler(c, resp, relayMode)
-			if err != nil {
-				return err
-			}
-			textResponse.Content = responseText
-			textResponse.Usage.PromptTokens = promptTokens
-			textResponse.Usage.CompletionTokens = countTokenText(responseText, textRequest.Model)
-			return nil
-		} else {
-			err, usage := openaiHandler(c, resp, promptTokens, textRequest.Model)
-			if err != nil {
-				return err
-			}
-			if usage != nil {
-				textResponse.Usage = *usage
-			}
-			return nil
-		}
-	case APITypeClaude:
-		if isStream {
-			err, responseText := claudeStreamHandler(c, resp)
-			if err != nil {
-				return err
-			}
-			textResponse.Content = responseText
-			textResponse.Usage.PromptTokens = promptTokens
-			textResponse.Usage.CompletionTokens = countTokenText(responseText, textRequest.Model)
-			return nil
-		} else {
-			err, usage := claudeHandler(c, resp, promptTokens, textRequest.Model)
-			if err != nil {
-				return err
-			}
-			if usage != nil {
-				textResponse.Usage = *usage
-			}
-			return nil
-		}
-	// case APITypeBaidu:
-	// 	if isStream {
-	// 		err, usage := baiduStreamHandler(c, resp)
-	// 		if err != nil {
-	// 			return err
-	// 		}
-	// 		if usage != nil {
-	// 			textResponse.Usage = *usage
-	// 		}
-	// 		return nil
-	// 	} else {
-	// 		var err *OpenAIErrorWithStatusCode
-	// 		var usage *Usage
-	// 		switch relayMode {
-	// 		case RelayModeEmbeddings:
-	// 			err, usage = baiduEmbeddingHandler(c, resp)
-	// 		default:
-	// 			err, usage = baiduHandler(c, resp)
-	// 		}
-	// 		if err != nil {
-	// 			return err
-	// 		}
-	// 		if usage != nil {
-	// 			textResponse.Usage = *usage
-	// 		}
-	// 		return nil
-	// 	}
-	case APITypePaLM:
-		if textRequest.Stream { // PaLM2 API does not support stream
-			err, responseText := palmStreamHandler(c, resp)
-			if err != nil {
-				return err
-			}
-			textResponse.Content = responseText
-			textResponse.Usage.PromptTokens = promptTokens
-			textResponse.Usage.CompletionTokens = countTokenText(responseText, textRequest.Model)
-			return nil
-		} else {
-			err, usage := palmHandler(c, resp, promptTokens, textRequest.Model)
-			if err != nil {
-				return err
-			}
-			if usage != nil {
-				textResponse.Usage = *usage
-			}
-			return nil
-		}
-	case APITypeGemini:
-		if textRequest.Stream {
-			err, responseText := geminiChatStreamHandler(c, resp)
-			if err != nil {
-				return err
-			}
-			textResponse.Content = responseText
-			textResponse.Usage.PromptTokens = promptTokens
-			textResponse.Usage.CompletionTokens = countTokenText(responseText, textRequest.Model)
-			return nil
-		} else {
-			err, usage := geminiChatHandler(c, resp, promptTokens, textRequest.Model)
-			if err != nil {
-				return err
-			}
-			if usage != nil {
-				textResponse.Usage = *usage
-			}
-			return nil
-		}
-	// case APITypeZhipu:
-	// 	if isStream {
-	// 		err, usage := zhipuStreamHandler(c, resp)
-	// 		if err != nil {
-	// 			return err
-	// 		}
-	// 		if usage != nil {
-	// 			textResponse.Usage = *usage
-	// 		}
-	// 		// zhipu's API does not return prompt tokens & completion tokens
-	// 		textResponse.Usage.PromptTokens = textResponse.Usage.TotalTokens
-	// 		return nil
-	// 	} else {
-	// 		err, usage := zhipuHandler(c, resp)
-	// 		if err != nil {
-	// 			return err
-	// 		}
-	// 		if usage != nil {
-	// 			textResponse.Usage = *usage
-	// 		}
-	// 		// zhipu's API does not return prompt tokens & completion tokens
-	// 		textResponse.Usage.PromptTokens = textResponse.Usage.TotalTokens
-	// 		return nil
-	// 	}
-	// case APITypeAli:
-	// 	if isStream {
-	// 		err, usage := aliStreamHandler(c, resp)
-	// 		if err != nil {
-	// 			return err
-	// 		}
-	// 		if usage != nil {
-	// 			textResponse.Usage = *usage
-	// 		}
-	// 		return nil
-	// 	} else {
-	// 		var err *OpenAIErrorWithStatusCode
-	// 		var usage *Usage
-	// 		switch relayMode {
-	// 		case RelayModeEmbeddings:
-	// 			err, usage = aliEmbeddingHandler(c, resp)
-	// 		default:
-	// 			err, usage = aliHandler(c, resp)
-	// 		}
-	// 		if err != nil {
-	// 			return err
-	// 		}
-	// 		if usage != nil {
-	// 			textResponse.Usage = *usage
-	// 		}
-	// 		return nil
-	// 	}
-	// case APITypeXunfei:
-	// 	auth := c.Request.Header.Get("Authorization")
-	// 	auth = strings.TrimPrefix(auth, "Bearer ")
-	// 	splits := strings.Split(auth, "|")
-	// 	if len(splits) != 3 {
-	// 		return errorWrapper(errors.New("invalid auth"), "invalid_auth", http.StatusBadRequest)
-	// 	}
-	// 	var err *OpenAIErrorWithStatusCode
-	// 	var usage *Usage
-	// 	if isStream {
-	// 		err, usage = xunfeiStreamHandler(c, textRequest, splits[0], splits[1], splits[2])
-	// 	} else {
-	// 		err, usage = xunfeiHandler(c, textRequest, splits[0], splits[1], splits[2])
-	// 	}
-	// 	if err != nil {
-	// 		return err
-	// 	}
-	// 	if usage != nil {
-	// 		textResponse.Usage = *usage
-	// 	}
-	// 	return nil
-	case APITypeAIProxyLibrary:
-		if isStream {
-			err, usage := aiProxyLibraryStreamHandler(c, resp)
-			if err != nil {
-				return err
-			}
-			if usage != nil {
-				textResponse.Usage = *usage
-			}
-			return nil
-		} else {
-			err, usage := aiProxyLibraryHandler(c, resp)
-			if err != nil {
-				return err
-			}
-			if usage != nil {
-				textResponse.Usage = *usage
-			}
-			return nil
-		}
-	// case APITypeTencent:
-	// 	if isStream {
-	// 		err, responseText := tencentStreamHandler(c, resp)
-	// 		if err != nil {
-	// 			return err
-	// 		}
-	// 		textResponse.Usage.PromptTokens = promptTokens
-	// 		textResponse.Usage.CompletionTokens = countTokenText(responseText, textRequest.Model)
-	// 		return nil
-	// 	} else {
-	// 		err, usage := tencentHandler(c, resp)
-	// 		if err != nil {
-	// 			return err
-	// 		}
-	// 		if usage != nil {
-	// 			textResponse.Usage = *usage
-	// 		}
-	// 		return nil
-	// 	}
-	default:
-		return errorWrapper(errors.New("unknown api type"), "unknown_api_type", http.StatusInternalServerError)
-	}
-}

controller/relay-utils.go

@@ -1,479 +0,0 @@
-package controller
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"math"
-	"net/http"
-	"one-api/common"
-	"one-api/common/image"
-	"one-api/model"
-	"strconv"
-	"strings"
-
-	"github.com/Laisky/errors/v2"
-	"github.com/gin-gonic/gin"
-	"github.com/pkoukk/tiktoken-go"
-)
-
-var stopFinishReason = "stop"
-
-// tokenEncoderMap won't grow after initialization
-var tokenEncoderMap = map[string]*tiktoken.Tiktoken{}
-var defaultTokenEncoder *tiktoken.Tiktoken
-
-func InitTokenEncoders() {
-	common.SysLog("initializing token encoders")
-	gpt35TokenEncoder, err := tiktoken.EncodingForModel("gpt-3.5-turbo")
-	if err != nil {
-		common.FatalLog(fmt.Sprintf("failed to get gpt-3.5-turbo token encoder: %s", err.Error()))
-	}
-	defaultTokenEncoder = gpt35TokenEncoder
-	gpt4TokenEncoder, err := tiktoken.EncodingForModel("gpt-4")
-	if err != nil {
-		common.FatalLog(fmt.Sprintf("failed to get gpt-4 token encoder: %s", err.Error()))
-	}
-	for model := range common.ModelRatio {
-		if strings.HasPrefix(model, "gpt-3.5") {
-			tokenEncoderMap[model] = gpt35TokenEncoder
-		} else if strings.HasPrefix(model, "gpt-4") {
-			tokenEncoderMap[model] = gpt4TokenEncoder
-		} else {
-			tokenEncoderMap[model] = nil
-		}
-	}
-	common.SysLog("token encoders initialized")
-}
-
-func getTokenEncoder(model string) *tiktoken.Tiktoken {
-	tokenEncoder, ok := tokenEncoderMap[model]
-	if ok && tokenEncoder != nil {
-		return tokenEncoder
-	}
-	if ok {
-		tokenEncoder, err := tiktoken.EncodingForModel(model)
-		if err != nil {
-			common.SysError(fmt.Sprintf("failed to get token encoder for model %s: %s, using encoder for gpt-3.5-turbo", model, err.Error()))
-			tokenEncoder = defaultTokenEncoder
-		}
-		tokenEncoderMap[model] = tokenEncoder
-		return tokenEncoder
-	}
-	return defaultTokenEncoder
-}
-
-func getTokenNum(tokenEncoder *tiktoken.Tiktoken, text string) int {
-	if common.ApproximateTokenEnabled {
-		return int(float64(len(text)) * 0.38)
-	}
-	return len(tokenEncoder.Encode(text, nil, nil))
-}
-
-// CountVisionImageToken count vision image tokens
-//
-// https://openai.com/pricing
-// func CountVisionImageToken(cnt []byte, resolution VisionImageResolution) (int, error) {
-// 	width, height, err := imageSize(cnt)
-// 	if err != nil {
-// 		return 0, errors.Wrap(err, "get image size")
-// 	}
-
-// 	switch resolution {
-// 	case VisionImageResolutionLow:
-// 		return 85, nil // fixed price
-// 	case VisionImageResolutionHigh:
-// 		h := math.Ceil(float64(height) / 512)
-// 		w := math.Ceil(float64(width) / 512)
-// 		n := w * h
-// 		total := 85 + 170*n
-// 		return int(total), nil
-// 	default:
-// 		return 0, errors.Errorf("unsupport resolution %q", resolution)
-// 	}
-// }
-
-// func imageSize(cnt []byte) (width, height int, err error) {
-// 	contentType := http.DetectContentType(cnt)
-// 	switch contentType {
-// 	case "image/jpeg", "image/jpg":
-// 		img, err := jpeg.Decode(bytes.NewReader(cnt))
-// 		if err != nil {
-// 			return 0, 0, errors.Wrap(err, "decode jpeg")
-// 		}
-
-// 		bounds := img.Bounds()
-// 		return bounds.Dx(), bounds.Dy(), nil
-// 	case "image/png":
-// 		img, err := png.Decode(bytes.NewReader(cnt))
-// 		if err != nil {
-// 			return 0, 0, errors.Wrap(err, "decode png")
-// 		}
-
-// 		bounds := img.Bounds()
-// 		return bounds.Dx(), bounds.Dy(), nil
-// 	default:
-// 		return 0, 0, errors.Errorf("unsupport image content type %q", contentType)
-// 	}
-// }
-
-func countTokenMessages(messages []Message, model string) int {
-	tokenEncoder := getTokenEncoder(model)
-	// Reference:
-	// https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
-	// https://github.com/pkoukk/tiktoken-go/issues/6
-	//
-	// Every message follows <|start|>{role/name}\n{content}<|end|>\n
-	var tokensPerMessage int
-	var tokensPerName int
-	if model == "gpt-3.5-turbo-0301" {
-		tokensPerMessage = 4
-		tokensPerName = -1 // If there's a name, the role is omitted
-	} else {
-		tokensPerMessage = 3
-		tokensPerName = 1
-	}
-	tokenNum := 0
-	for _, message := range messages {
-		tokenNum += tokensPerMessage
-		switch v := message.Content.(type) {
-		case string:
-			tokenNum += getTokenNum(tokenEncoder, v)
-		case []any:
-			for _, it := range v {
-				m := it.(map[string]any)
-				switch m["type"] {
-				case "text":
-					tokenNum += getTokenNum(tokenEncoder, m["text"].(string))
-				case "image_url":
-					imageUrl, ok := m["image_url"].(map[string]any)
-					if ok {
-						url := imageUrl["url"].(string)
-						detail := ""
-						if imageUrl["detail"] != nil {
-							detail = imageUrl["detail"].(string)
-						}
-						imageTokens, err := countImageTokens(url, detail)
-						if err != nil {
-							common.SysError("error counting image tokens: " + err.Error())
-						} else {
-							tokenNum += imageTokens
-						}
-					}
-				}
-			}
-		}
-		tokenNum += getTokenNum(tokenEncoder, message.Role)
-		if message.Name != nil {
-			tokenNum += tokensPerName
-			tokenNum += getTokenNum(tokenEncoder, *message.Name)
-		}
-	}
-	tokenNum += 3 // Every reply is primed with <|start|>assistant<|message|>
-	return tokenNum
-}
-
-// func countVisonTokenMessages(messages []VisionMessage, model string) (int, error) {
-// 	tokenEncoder := getTokenEncoder(model)
-// 	// Reference:
-// 	// https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
-// 	// https://github.com/pkoukk/tiktoken-go/issues/6
-// 	//
-// 	// Every message follows <|start|>{role/name}\n{content}<|end|>\n
-// 	var tokensPerMessage int
-// 	var tokensPerName int
-// 	if model == "gpt-3.5-turbo-0301" {
-// 		tokensPerMessage = 4
-// 		tokensPerName = -1 // If there's a name, the role is omitted
-// 	} else {
-// 		tokensPerMessage = 3
-// 		tokensPerName = 1
-// 	}
-// 	tokenNum := 0
-// 	for _, message := range messages {
-// 		tokenNum += tokensPerMessage
-// 		for _, cnt := range message.Content {
-// 			switch cnt.Type {
-// 			case OpenaiVisionMessageContentTypeText:
-// 				tokenNum += getTokenNum(tokenEncoder, cnt.Text)
-// 			case OpenaiVisionMessageContentTypeImageUrl:
-// 				imgblob, err := base64.StdEncoding.DecodeString(strings.TrimPrefix(cnt.ImageUrl.URL, "data:image/jpeg;base64,"))
-// 				if err != nil {
-// 					return 0, errors.Wrap(err, "failed to decode base64 image")
-// 				}
-
-// 				if imgtoken, err := CountVisionImageToken(imgblob, cnt.ImageUrl.Detail); err != nil {
-// 					return 0, errors.Wrap(err, "failed to count vision image token")
-// 				} else {
-// 					tokenNum += imgtoken
-// 				}
-// 			}
-// 		}
-
-// 		tokenNum += getTokenNum(tokenEncoder, message.Role)
-// 		if message.Name != nil {
-// 			tokenNum += tokensPerName
-// 			tokenNum += getTokenNum(tokenEncoder, *message.Name)
-// 		}
-// 	}
-// 	tokenNum += 3 // Every reply is primed with <|start|>assistant<|message|>
-// 	return tokenNum, nil
-// }
-
-const (
-	lowDetailCost         = 85
-	highDetailCostPerTile = 170
-	additionalCost        = 85
-)
-
-// https://platform.openai.com/docs/guides/vision/calculating-costs
-// https://github.com/openai/openai-cookbook/blob/05e3f9be4c7a2ae7ecf029a7c32065b024730ebe/examples/How_to_count_tokens_with_tiktoken.ipynb
-func countImageTokens(url string, detail string) (_ int, err error) {
-	var fetchSize = true
-	var width, height int
-	// Reference: https://platform.openai.com/docs/guides/vision/low-or-high-fidelity-image-understanding
-	// detail == "auto" is undocumented on how it works, it just said the model will use the auto setting which will look at the image input size and decide if it should use the low or high setting.
-	// According to the official guide, "low" disable the high-res model,
-	// and only receive low-res 512px x 512px version of the image, indicating
-	// that image is treated as low-res when size is smaller than 512px x 512px,
-	// then we can assume that image size larger than 512px x 512px is treated
-	// as high-res. Then we have the following logic:
-	// if detail == "" || detail == "auto" {
-	// 	width, height, err = image.GetImageSize(url)
-	// 	if err != nil {
-	// 		return 0, err
-	// 	}
-	// 	fetchSize = false
-	// 	// not sure if this is correct
-	// 	if width > 512 || height > 512 {
-	// 		detail = "high"
-	// 	} else {
-	// 		detail = "low"
-	// 	}
-	// }
-
-	// However, in my test, it seems to be always the same as "high".
-	// The following image, which is 125x50, is still treated as high-res, taken
-	// 255 tokens in the response of non-stream chat completion api.
-	// https://upload.wikimedia.org/wikipedia/commons/1/10/18_Infantry_Division_Messina.jpg
-	if detail == "" || detail == "auto" {
-		// assume by test, not sure if this is correct
-		detail = "high"
-	}
-	switch detail {
-	case "low":
-		return lowDetailCost, nil
-	case "high":
-		if fetchSize {
-			width, height, err = image.GetImageSize(url)
-			if err != nil {
-				return 0, err
-			}
-		}
-		if width > 2048 || height > 2048 { // max(width, height) > 2048
-			ratio := float64(2048) / math.Max(float64(width), float64(height))
-			width = int(float64(width) * ratio)
-			height = int(float64(height) * ratio)
-		}
-		if width > 768 && height > 768 { // min(width, height) > 768
-			ratio := float64(768) / math.Min(float64(width), float64(height))
-			width = int(float64(width) * ratio)
-			height = int(float64(height) * ratio)
-		}
-		numSquares := int(math.Ceil(float64(width)/512) * math.Ceil(float64(height)/512))
-		result := numSquares*highDetailCostPerTile + additionalCost
-		return result, nil
-	default:
-		return 0, errors.New("invalid detail option")
-	}
-}
-
-func countTokenInput(input any, model string) int {
-	switch v := input.(type) {
-	case string:
-		return countTokenText(v, model)
-	case []string:
-		text := ""
-		for _, s := range v {
-			text += s
-		}
-		return countTokenText(text, model)
-	}
-	return 0
-}
-
-func countTokenText(text string, model string) int {
-	tokenEncoder := getTokenEncoder(model)
-	return getTokenNum(tokenEncoder, text)
-}
-
-func errorWrapper(err error, code string, statusCode int) *OpenAIErrorWithStatusCode {
-	openAIError := OpenAIError{
-		Message: err.Error(),
-		Type:    "one_api_error",
-		Code:    code,
-	}
-	return &OpenAIErrorWithStatusCode{
-		OpenAIError: openAIError,
-		StatusCode:  statusCode,
-	}
-}
-
-func shouldDisableChannel(err *OpenAIError, statusCode int) bool {
-	if !common.AutomaticDisableChannelEnabled {
-		return false
-	}
-	if err == nil {
-		return false
-	}
-	if statusCode == http.StatusUnauthorized {
-		return true
-	}
-	if err.Type == "insufficient_quota" || err.Code == "invalid_api_key" || err.Code == "account_deactivated" {
-		return true
-	}
-	return false
-}
-
-func shouldEnableChannel(err error, openAIErr *OpenAIError) bool {
-	if !common.AutomaticEnableChannelEnabled {
-		return false
-	}
-	if err != nil {
-		return false
-	}
-	if openAIErr != nil {
-		return false
-	}
-	return true
-}
-
-func setEventStreamHeaders(c *gin.Context) {
-	c.Writer.Header().Set("Content-Type", "text/event-stream")
-	c.Writer.Header().Set("Cache-Control", "no-cache")
-	c.Writer.Header().Set("Connection", "keep-alive")
-	c.Writer.Header().Set("Transfer-Encoding", "chunked")
-	c.Writer.Header().Set("X-Accel-Buffering", "no")
-}
-
-type GeneralErrorResponse struct {
-	Error    OpenAIError `json:"error"`
-	Message  string      `json:"message"`
-	Msg      string      `json:"msg"`
-	Err      string      `json:"err"`
-	ErrorMsg string      `json:"error_msg"`
-	Header   struct {
-		Message string `json:"message"`
-	} `json:"header"`
-	Response struct {
-		Error struct {
-			Message string `json:"message"`
-		} `json:"error"`
-	} `json:"response"`
-}
-
-func (e GeneralErrorResponse) ToMessage() string {
-	if e.Error.Message != "" {
-		return e.Error.Message
-	}
-	if e.Message != "" {
-		return e.Message
-	}
-	if e.Msg != "" {
-		return e.Msg
-	}
-	if e.Err != "" {
-		return e.Err
-	}
-	if e.ErrorMsg != "" {
-		return e.ErrorMsg
-	}
-	if e.Header.Message != "" {
-		return e.Header.Message
-	}
-	if e.Response.Error.Message != "" {
-		return e.Response.Error.Message
-	}
-	return ""
-}
-
-func relayErrorHandler(resp *http.Response) (openAIErrorWithStatusCode *OpenAIErrorWithStatusCode) {
-	openAIErrorWithStatusCode = &OpenAIErrorWithStatusCode{
-		StatusCode: resp.StatusCode,
-		OpenAIError: OpenAIError{
-			Message: "",
-			Type:    "upstream_error",
-			Code:    "bad_response_status_code",
-			Param:   strconv.Itoa(resp.StatusCode),
-		},
-	}
-	responseBody, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return
-	}
-	err = resp.Body.Close()
-	if err != nil {
-		return
-	}
-	var errResponse GeneralErrorResponse
-	err = json.Unmarshal(responseBody, &errResponse)
-	if err != nil {
-		return
-	}
-	if errResponse.Error.Message != "" {
-		// OpenAI format error, so we override the default one
-		openAIErrorWithStatusCode.OpenAIError = errResponse.Error
-	} else {
-		openAIErrorWithStatusCode.OpenAIError.Message = errResponse.ToMessage()
-	}
-	if openAIErrorWithStatusCode.OpenAIError.Message == "" {
-		openAIErrorWithStatusCode.OpenAIError.Message = fmt.Sprintf("bad response status code %d", resp.StatusCode)
-	}
-	return
-}
-
-func getFullRequestURL(baseURL string, requestURL string, channelType int) string {
-	fullRequestURL := fmt.Sprintf("%s%s", baseURL, requestURL)
-
-	if strings.HasPrefix(baseURL, "https://gateway.ai.cloudflare.com") {
-		switch channelType {
-		case common.ChannelTypeOpenAI:
-			fullRequestURL = fmt.Sprintf("%s%s", baseURL, strings.TrimPrefix(requestURL, "/v1"))
-		case common.ChannelTypeAzure:
-			fullRequestURL = fmt.Sprintf("%s%s", baseURL, strings.TrimPrefix(requestURL, "/openai/deployments"))
-		}
-	}
-	return fullRequestURL
-}
-
-func postConsumeQuota(ctx context.Context, tokenId int, quotaDelta int, totalQuota int, userId int, channelId int, modelRatio float64, groupRatio float64, modelName string, tokenName string) {
-	// quotaDelta is remaining quota to be consumed
-	err := model.PostConsumeTokenQuota(tokenId, quotaDelta)
-	if err != nil {
-		common.SysError("error consuming token remain quota: " + err.Error())
-	}
-	err = model.CacheUpdateUserQuota(userId)
-	if err != nil {
-		common.SysError("error update user quota cache: " + err.Error())
-	}
-	// totalQuota is total quota consumed
-	if totalQuota != 0 {
-		logContent := fmt.Sprintf("模型倍率 %.2f，分组倍率 %.2f", modelRatio, groupRatio)
-		model.RecordConsumeLog(ctx, userId, channelId, totalQuota, 0, modelName, tokenName, totalQuota, logContent)
-		model.UpdateUserUsedQuotaAndRequestCount(userId, totalQuota)
-		model.UpdateChannelUsedQuota(channelId, totalQuota)
-	}
-	if totalQuota <= 0 {
-		common.LogError(ctx, fmt.Sprintf("totalQuota consumed is %d, something is wrong", totalQuota))
-	}
-}
-
-func GetAPIVersion(c *gin.Context) string {
-	query := c.Request.URL.Query()
-	apiVersion := query.Get("api-version")
-	if apiVersion == "" {
-		apiVersion = c.GetString("api_version")
-	}
-	return apiVersion
-}

controller/relay-xunfei.go

@@ -1,306 +0,0 @@
-package controller
-
-// import (
-// 	"crypto/hmac"
-// 	"crypto/sha256"
-// 	"encoding/base64"
-// 	"encoding/json"
-// 	"fmt"
-// 	"github.com/gin-gonic/gin"
-// 	"github.com/gorilla/websocket"
-// 	"io"
-// 	"net/http"
-// 	"net/url"
-// 	"one-api/common"
-// 	"strings"
-// 	"time"
-// )
-
-// // https://console.xfyun.cn/services/cbm
-// // https://www.xfyun.cn/doc/spark/Web.html
-
-// type XunfeiMessage struct {
-// 	Role    string `json:"role"`
-// 	Content string `json:"content"`
-// }
-
-// type XunfeiChatRequest struct {
-// 	Header struct {
-// 		AppId string `json:"app_id"`
-// 	} `json:"header"`
-// 	Parameter struct {
-// 		Chat struct {
-// 			Domain      string  `json:"domain,omitempty"`
-// 			Temperature float64 `json:"temperature,omitempty"`
-// 			TopK        int     `json:"top_k,omitempty"`
-// 			MaxTokens   int     `json:"max_tokens,omitempty"`
-// 			Auditing    bool    `json:"auditing,omitempty"`
-// 		} `json:"chat"`
-// 	} `json:"parameter"`
-// 	Payload struct {
-// 		Message struct {
-// 			Text []XunfeiMessage `json:"text"`
-// 		} `json:"message"`
-// 	} `json:"payload"`
-// }
-
-// type XunfeiChatResponseTextItem struct {
-// 	Content string `json:"content"`
-// 	Role    string `json:"role"`
-// 	Index   int    `json:"index"`
-// }
-
-// type XunfeiChatResponse struct {
-// 	Header struct {
-// 		Code    int    `json:"code"`
-// 		Message string `json:"message"`
-// 		Sid     string `json:"sid"`
-// 		Status  int    `json:"status"`
-// 	} `json:"header"`
-// 	Payload struct {
-// 		Choices struct {
-// 			Status int                          `json:"status"`
-// 			Seq    int                          `json:"seq"`
-// 			Text   []XunfeiChatResponseTextItem `json:"text"`
-// 		} `json:"choices"`
-// 		Usage struct {
-// 			//Text struct {
-// 			//	QuestionTokens   string `json:"question_tokens"`
-// 			//	PromptTokens     string `json:"prompt_tokens"`
-// 			//	CompletionTokens string `json:"completion_tokens"`
-// 			//	TotalTokens      string `json:"total_tokens"`
-// 			//} `json:"text"`
-// 			Text Usage `json:"text"`
-// 		} `json:"usage"`
-// 	} `json:"payload"`
-// }
-
-// func requestOpenAI2Xunfei(request GeneralOpenAIRequest, xunfeiAppId string, domain string) *XunfeiChatRequest {
-// 	messages := make([]XunfeiMessage, 0, len(request.Messages))
-// 	for _, message := range request.Messages {
-// 		if message.Role == "system" {
-// 			messages = append(messages, XunfeiMessage{
-// 				Role:    "user",
-// 				Content: message.Content,
-// 			})
-// 			messages = append(messages, XunfeiMessage{
-// 				Role:    "assistant",
-// 				Content: "Okay",
-// 			})
-// 		} else {
-// 			messages = append(messages, XunfeiMessage{
-// 				Role:    message.Role,
-// 				Content: message.Content,
-// 			})
-// 		}
-// 	}
-// 	xunfeiRequest := XunfeiChatRequest{}
-// 	xunfeiRequest.Header.AppId = xunfeiAppId
-// 	xunfeiRequest.Parameter.Chat.Domain = domain
-// 	xunfeiRequest.Parameter.Chat.Temperature = request.Temperature
-// 	xunfeiRequest.Parameter.Chat.TopK = request.N
-// 	xunfeiRequest.Parameter.Chat.MaxTokens = request.MaxTokens
-// 	xunfeiRequest.Payload.Message.Text = messages
-// 	return &xunfeiRequest
-// }
-
-// func responseXunfei2OpenAI(response *XunfeiChatResponse) *OpenAITextResponse {
-// 	if len(response.Payload.Choices.Text) == 0 {
-// 		response.Payload.Choices.Text = []XunfeiChatResponseTextItem{
-// 			{
-// 				Content: "",
-// 			},
-// 		}
-// 	}
-// 	choice := OpenAITextResponseChoice{
-// 		Index: 0,
-// 		Message: Message{
-// 			Role:    "assistant",
-// 			Content: response.Payload.Choices.Text[0].Content,
-// 		},
-// 		FinishReason: stopFinishReason,
-// 	}
-// 	fullTextResponse := OpenAITextResponse{
-// 		Object:  "chat.completion",
-// 		Created: common.GetTimestamp(),
-// 		Choices: []OpenAITextResponseChoice{choice},
-// 		Usage:   response.Payload.Usage.Text,
-// 	}
-// 	return &fullTextResponse
-// }
-
-// func streamResponseXunfei2OpenAI(xunfeiResponse *XunfeiChatResponse) *ChatCompletionsStreamResponse {
-// 	if len(xunfeiResponse.Payload.Choices.Text) == 0 {
-// 		xunfeiResponse.Payload.Choices.Text = []XunfeiChatResponseTextItem{
-// 			{
-// 				Content: "",
-// 			},
-// 		}
-// 	}
-// 	var choice ChatCompletionsStreamResponseChoice
-// 	choice.Delta.Content = xunfeiResponse.Payload.Choices.Text[0].Content
-// 	if xunfeiResponse.Payload.Choices.Status == 2 {
-// 		choice.FinishReason = &stopFinishReason
-// 	}
-// 	response := ChatCompletionsStreamResponse{
-// 		Object:  "chat.completion.chunk",
-// 		Created: common.GetTimestamp(),
-// 		Model:   "SparkDesk",
-// 		Choices: []ChatCompletionsStreamResponseChoice{choice},
-// 	}
-// 	return &response
-// }
-
-// func buildXunfeiAuthUrl(hostUrl string, apiKey, apiSecret string) string {
-// 	HmacWithShaToBase64 := func(algorithm, data, key string) string {
-// 		mac := hmac.New(sha256.New, []byte(key))
-// 		mac.Write([]byte(data))
-// 		encodeData := mac.Sum(nil)
-// 		return base64.StdEncoding.EncodeToString(encodeData)
-// 	}
-// 	ul, err := url.Parse(hostUrl)
-// 	if err != nil {
-// 		fmt.Println(err)
-// 	}
-// 	date := time.Now().UTC().Format(time.RFC1123)
-// 	signString := []string{"host: " + ul.Host, "date: " + date, "GET " + ul.Path + " HTTP/1.1"}
-// 	sign := strings.Join(signString, "\n")
-// 	sha := HmacWithShaToBase64("hmac-sha256", sign, apiSecret)
-// 	authUrl := fmt.Sprintf("hmac username=\"%s\", algorithm=\"%s\", headers=\"%s\", signature=\"%s\"", apiKey,
-// 		"hmac-sha256", "host date request-line", sha)
-// 	authorization := base64.StdEncoding.EncodeToString([]byte(authUrl))
-// 	v := url.Values{}
-// 	v.Add("host", ul.Host)
-// 	v.Add("date", date)
-// 	v.Add("authorization", authorization)
-// 	callUrl := hostUrl + "?" + v.Encode()
-// 	return callUrl
-// }
-
-// func xunfeiStreamHandler(c *gin.Context, textRequest GeneralOpenAIRequest, appId string, apiSecret string, apiKey string) (*OpenAIErrorWithStatusCode, *Usage) {
-// 	domain, authUrl := getXunfeiAuthUrl(c, apiKey, apiSecret)
-// 	dataChan, stopChan, err := xunfeiMakeRequest(textRequest, domain, authUrl, appId)
-// 	if err != nil {
-// 		return errorWrapper(err, "make xunfei request err", http.StatusInternalServerError), nil
-// 	}
-// 	setEventStreamHeaders(c)
-// 	var usage Usage
-// 	c.Stream(func(w io.Writer) bool {
-// 		select {
-// 		case xunfeiResponse := <-dataChan:
-// 			usage.PromptTokens += xunfeiResponse.Payload.Usage.Text.PromptTokens
-// 			usage.CompletionTokens += xunfeiResponse.Payload.Usage.Text.CompletionTokens
-// 			usage.TotalTokens += xunfeiResponse.Payload.Usage.Text.TotalTokens
-// 			response := streamResponseXunfei2OpenAI(&xunfeiResponse)
-// 			jsonResponse, err := json.Marshal(response)
-// 			if err != nil {
-// 				common.SysError("error marshalling stream response: " + err.Error())
-// 				return true
-// 			}
-// 			c.Render(-1, common.CustomEvent{Data: "data: " + string(jsonResponse)})
-// 			return true
-// 		case <-stopChan:
-// 			c.Render(-1, common.CustomEvent{Data: "data: [DONE]"})
-// 			return false
-// 		}
-// 	})
-// 	return nil, &usage
-// }
-
-// func xunfeiHandler(c *gin.Context, textRequest GeneralOpenAIRequest, appId string, apiSecret string, apiKey string) (*OpenAIErrorWithStatusCode, *Usage) {
-// 	domain, authUrl := getXunfeiAuthUrl(c, apiKey, apiSecret)
-// 	dataChan, stopChan, err := xunfeiMakeRequest(textRequest, domain, authUrl, appId)
-// 	if err != nil {
-// 		return errorWrapper(err, "make xunfei request err", http.StatusInternalServerError), nil
-// 	}
-// 	var usage Usage
-// 	var content string
-// 	var xunfeiResponse XunfeiChatResponse
-// 	stop := false
-// 	for !stop {
-// 		select {
-// 		case xunfeiResponse = <-dataChan:
-// 			if len(xunfeiResponse.Payload.Choices.Text) == 0 {
-// 				continue
-// 			}
-// 			content += xunfeiResponse.Payload.Choices.Text[0].Content
-// 			usage.PromptTokens += xunfeiResponse.Payload.Usage.Text.PromptTokens
-// 			usage.CompletionTokens += xunfeiResponse.Payload.Usage.Text.CompletionTokens
-// 			usage.TotalTokens += xunfeiResponse.Payload.Usage.Text.TotalTokens
-// 		case stop = <-stopChan:
-// 		}
-// 	}
-
-// 	xunfeiResponse.Payload.Choices.Text[0].Content = content
-
-// 	response := responseXunfei2OpenAI(&xunfeiResponse)
-// 	jsonResponse, err := json.Marshal(response)
-// 	if err != nil {
-// 		return errorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	c.Writer.Header().Set("Content-Type", "application/json")
-// 	_, _ = c.Writer.Write(jsonResponse)
-// 	return nil, &usage
-// }
-
-// func xunfeiMakeRequest(textRequest GeneralOpenAIRequest, domain, authUrl, appId string) (chan XunfeiChatResponse, chan bool, error) {
-// 	d := websocket.Dialer{
-// 		HandshakeTimeout: 5 * time.Second,
-// 	}
-// 	conn, resp, err := d.Dial(authUrl, nil)
-// 	if err != nil || resp.StatusCode != 101 {
-// 		return nil, nil, err
-// 	}
-// 	data := requestOpenAI2Xunfei(textRequest, appId, domain)
-// 	err = conn.WriteJSON(data)
-// 	if err != nil {
-// 		return nil, nil, err
-// 	}
-
-// 	dataChan := make(chan XunfeiChatResponse)
-// 	stopChan := make(chan bool)
-// 	go func() {
-// 		for {
-// 			_, msg, err := conn.ReadMessage()
-// 			if err != nil {
-// 				common.SysError("error reading stream response: " + err.Error())
-// 				break
-// 			}
-// 			var response XunfeiChatResponse
-// 			err = json.Unmarshal(msg, &response)
-// 			if err != nil {
-// 				common.SysError("error unmarshalling stream response: " + err.Error())
-// 				break
-// 			}
-// 			dataChan <- response
-// 			if response.Payload.Choices.Status == 2 {
-// 				err := conn.Close()
-// 				if err != nil {
-// 					common.SysError("error closing websocket connection: " + err.Error())
-// 				}
-// 				break
-// 			}
-// 		}
-// 		stopChan <- true
-// 	}()
-
-// 	return dataChan, stopChan, nil
-// }
-
-// func getXunfeiAuthUrl(c *gin.Context, apiKey string, apiSecret string) (string, string) {
-// 	query := c.Request.URL.Query()
-// 	apiVersion := query.Get("api-version")
-// 	if apiVersion == "" {
-// 		apiVersion = c.GetString("api_version")
-// 	}
-// 	if apiVersion == "" {
-// 		apiVersion = "v1.1"
-// 		common.SysLog("api_version not found, use default: " + apiVersion)
-// 	}
-// 	domain := "general"
-// 	if apiVersion != "v1.1" {
-// 		domain += strings.Split(apiVersion, ".")[0]
-// 	}
-// 	authUrl := buildXunfeiAuthUrl(fmt.Sprintf("wss://spark-api.xf-yun.com/%s/chat", apiVersion), apiKey, apiSecret)
-// 	return domain, authUrl
-// }

controller/relay-zhipu.go

@@ -1,301 +0,0 @@
-package controller
-
-// import (
-// 	"bufio"
-// 	"encoding/json"
-// 	"github.com/gin-gonic/gin"
-// 	"github.com/golang-jwt/jwt"
-// 	"io"
-// 	"net/http"
-// 	"one-api/common"
-// 	"strings"
-// 	"sync"
-// 	"time"
-// )
-
-// // https://open.bigmodel.cn/doc/api#chatglm_std
-// // chatglm_std, chatglm_lite
-// // https://open.bigmodel.cn/api/paas/v3/model-api/chatglm_std/invoke
-// // https://open.bigmodel.cn/api/paas/v3/model-api/chatglm_std/sse-invoke
-
-// type ZhipuMessage struct {
-// 	Role    string `json:"role"`
-// 	Content string `json:"content"`
-// }
-
-// type ZhipuRequest struct {
-// 	Prompt      []ZhipuMessage `json:"prompt"`
-// 	Temperature float64        `json:"temperature,omitempty"`
-// 	TopP        float64        `json:"top_p,omitempty"`
-// 	RequestId   string         `json:"request_id,omitempty"`
-// 	Incremental bool           `json:"incremental,omitempty"`
-// }
-
-// type ZhipuResponseData struct {
-// 	TaskId     string         `json:"task_id"`
-// 	RequestId  string         `json:"request_id"`
-// 	TaskStatus string         `json:"task_status"`
-// 	Choices    []ZhipuMessage `json:"choices"`
-// 	Usage      `json:"usage"`
-// }
-
-// type ZhipuResponse struct {
-// 	Code    int               `json:"code"`
-// 	Msg     string            `json:"msg"`
-// 	Success bool              `json:"success"`
-// 	Data    ZhipuResponseData `json:"data"`
-// }
-
-// type ZhipuStreamMetaResponse struct {
-// 	RequestId  string `json:"request_id"`
-// 	TaskId     string `json:"task_id"`
-// 	TaskStatus string `json:"task_status"`
-// 	Usage      `json:"usage"`
-// }
-
-// type zhipuTokenData struct {
-// 	Token      string
-// 	ExpiryTime time.Time
-// }
-
-// var zhipuTokens sync.Map
-// var expSeconds int64 = 24 * 3600
-
-// func getZhipuToken(apikey string) string {
-// 	data, ok := zhipuTokens.Load(apikey)
-// 	if ok {
-// 		tokenData := data.(zhipuTokenData)
-// 		if time.Now().Before(tokenData.ExpiryTime) {
-// 			return tokenData.Token
-// 		}
-// 	}
-
-// 	split := strings.Split(apikey, ".")
-// 	if len(split) != 2 {
-// 		common.SysError("invalid zhipu key: " + apikey)
-// 		return ""
-// 	}
-
-// 	id := split[0]
-// 	secret := split[1]
-
-// 	expMillis := time.Now().Add(time.Duration(expSeconds)*time.Second).UnixNano() / 1e6
-// 	expiryTime := time.Now().Add(time.Duration(expSeconds) * time.Second)
-
-// 	timestamp := time.Now().UnixNano() / 1e6
-
-// 	payload := jwt.MapClaims{
-// 		"api_key":   id,
-// 		"exp":       expMillis,
-// 		"timestamp": timestamp,
-// 	}
-
-// 	token := jwt.NewWithClaims(jwt.SigningMethodHS256, payload)
-
-// 	token.Header["alg"] = "HS256"
-// 	token.Header["sign_type"] = "SIGN"
-
-// 	tokenString, err := token.SignedString([]byte(secret))
-// 	if err != nil {
-// 		return ""
-// 	}
-
-// 	zhipuTokens.Store(apikey, zhipuTokenData{
-// 		Token:      tokenString,
-// 		ExpiryTime: expiryTime,
-// 	})
-
-// 	return tokenString
-// }
-
-// func requestOpenAI2Zhipu(request GeneralOpenAIRequest) *ZhipuRequest {
-// 	messages := make([]ZhipuMessage, 0, len(request.Messages))
-// 	for _, message := range request.Messages {
-// 		if message.Role == "system" {
-// 			messages = append(messages, ZhipuMessage{
-// 				Role:    "system",
-// 				Content: message.Content,
-// 			})
-// 			messages = append(messages, ZhipuMessage{
-// 				Role:    "user",
-// 				Content: "Okay",
-// 			})
-// 		} else {
-// 			messages = append(messages, ZhipuMessage{
-// 				Role:    message.Role,
-// 				Content: message.Content,
-// 			})
-// 		}
-// 	}
-// 	return &ZhipuRequest{
-// 		Prompt:      messages,
-// 		Temperature: request.Temperature,
-// 		TopP:        request.TopP,
-// 		Incremental: false,
-// 	}
-// }
-
-// func responseZhipu2OpenAI(response *ZhipuResponse) *OpenAITextResponse {
-// 	fullTextResponse := OpenAITextResponse{
-// 		Id:      response.Data.TaskId,
-// 		Object:  "chat.completion",
-// 		Created: common.GetTimestamp(),
-// 		Choices: make([]OpenAITextResponseChoice, 0, len(response.Data.Choices)),
-// 		Usage:   response.Data.Usage,
-// 	}
-// 	for i, choice := range response.Data.Choices {
-// 		openaiChoice := OpenAITextResponseChoice{
-// 			Index: i,
-// 			Message: Message{
-// 				Role:    choice.Role,
-// 				Content: strings.Trim(choice.Content, "\""),
-// 			},
-// 			FinishReason: "",
-// 		}
-// 		if i == len(response.Data.Choices)-1 {
-// 			openaiChoice.FinishReason = "stop"
-// 		}
-// 		fullTextResponse.Choices = append(fullTextResponse.Choices, openaiChoice)
-// 	}
-// 	return &fullTextResponse
-// }
-
-// func streamResponseZhipu2OpenAI(zhipuResponse string) *ChatCompletionsStreamResponse {
-// 	var choice ChatCompletionsStreamResponseChoice
-// 	choice.Delta.Content = zhipuResponse
-// 	response := ChatCompletionsStreamResponse{
-// 		Object:  "chat.completion.chunk",
-// 		Created: common.GetTimestamp(),
-// 		Model:   "chatglm",
-// 		Choices: []ChatCompletionsStreamResponseChoice{choice},
-// 	}
-// 	return &response
-// }
-
-// func streamMetaResponseZhipu2OpenAI(zhipuResponse *ZhipuStreamMetaResponse) (*ChatCompletionsStreamResponse, *Usage) {
-// 	var choice ChatCompletionsStreamResponseChoice
-// 	choice.Delta.Content = ""
-// 	choice.FinishReason = &stopFinishReason
-// 	response := ChatCompletionsStreamResponse{
-// 		Id:      zhipuResponse.RequestId,
-// 		Object:  "chat.completion.chunk",
-// 		Created: common.GetTimestamp(),
-// 		Model:   "chatglm",
-// 		Choices: []ChatCompletionsStreamResponseChoice{choice},
-// 	}
-// 	return &response, &zhipuResponse.Usage
-// }
-
-// func zhipuStreamHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, *Usage) {
-// 	var usage *Usage
-// 	scanner := bufio.NewScanner(resp.Body)
-// 	scanner.Split(func(data []byte, atEOF bool) (advance int, token []byte, err error) {
-// 		if atEOF && len(data) == 0 {
-// 			return 0, nil, nil
-// 		}
-// 		if i := strings.Index(string(data), "\n\n"); i >= 0 && strings.Index(string(data), ":") >= 0 {
-// 			return i + 2, data[0:i], nil
-// 		}
-// 		if atEOF {
-// 			return len(data), data, nil
-// 		}
-// 		return 0, nil, nil
-// 	})
-// 	dataChan := make(chan string)
-// 	metaChan := make(chan string)
-// 	stopChan := make(chan bool)
-// 	go func() {
-// 		for scanner.Scan() {
-// 			data := scanner.Text()
-// 			lines := strings.Split(data, "\n")
-// 			for i, line := range lines {
-// 				if len(line) < 5 {
-// 					continue
-// 				}
-// 				if line[:5] == "data:" {
-// 					dataChan <- line[5:]
-// 					if i != len(lines)-1 {
-// 						dataChan <- "\n"
-// 					}
-// 				} else if line[:5] == "meta:" {
-// 					metaChan <- line[5:]
-// 				}
-// 			}
-// 		}
-// 		stopChan <- true
-// 	}()
-// 	setEventStreamHeaders(c)
-// 	c.Stream(func(w io.Writer) bool {
-// 		select {
-// 		case data := <-dataChan:
-// 			response := streamResponseZhipu2OpenAI(data)
-// 			jsonResponse, err := json.Marshal(response)
-// 			if err != nil {
-// 				common.SysError("error marshalling stream response: " + err.Error())
-// 				return true
-// 			}
-// 			c.Render(-1, common.CustomEvent{Data: "data: " + string(jsonResponse)})
-// 			return true
-// 		case data := <-metaChan:
-// 			var zhipuResponse ZhipuStreamMetaResponse
-// 			err := json.Unmarshal([]byte(data), &zhipuResponse)
-// 			if err != nil {
-// 				common.SysError("error unmarshalling stream response: " + err.Error())
-// 				return true
-// 			}
-// 			response, zhipuUsage := streamMetaResponseZhipu2OpenAI(&zhipuResponse)
-// 			jsonResponse, err := json.Marshal(response)
-// 			if err != nil {
-// 				common.SysError("error marshalling stream response: " + err.Error())
-// 				return true
-// 			}
-// 			usage = zhipuUsage
-// 			c.Render(-1, common.CustomEvent{Data: "data: " + string(jsonResponse)})
-// 			return true
-// 		case <-stopChan:
-// 			c.Render(-1, common.CustomEvent{Data: "data: [DONE]"})
-// 			return false
-// 		}
-// 	})
-// 	err := resp.Body.Close()
-// 	if err != nil {
-// 		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	return nil, usage
-// }
-
-// func zhipuHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, *Usage) {
-// 	var zhipuResponse ZhipuResponse
-// 	responseBody, err := io.ReadAll(resp.Body)
-// 	if err != nil {
-// 		return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	err = resp.Body.Close()
-// 	if err != nil {
-// 		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	err = json.Unmarshal(responseBody, &zhipuResponse)
-// 	if err != nil {
-// 		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	if !zhipuResponse.Success {
-// 		return &OpenAIErrorWithStatusCode{
-// 			OpenAIError: OpenAIError{
-// 				Message: zhipuResponse.Msg,
-// 				Type:    "zhipu_error",
-// 				Param:   "",
-// 				Code:    zhipuResponse.Code,
-// 			},
-// 			StatusCode: resp.StatusCode,
-// 		}, nil
-// 	}
-// 	fullTextResponse := responseZhipu2OpenAI(&zhipuResponse)
-// 	jsonResponse, err := json.Marshal(fullTextResponse)
-// 	if err != nil {
-// 		return errorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
-// 	}
-// 	c.Writer.Header().Set("Content-Type", "application/json")
-// 	c.Writer.WriteHeader(resp.StatusCode)
-// 	_, err = c.Writer.Write(jsonResponse)
-// 	return nil, &fullTextResponse.Usage
-// }

controller/relay.go

@@ -2,450 +2,57 @@ package controller
 
 import (
 	"fmt"
-	"net/http"
-	"one-api/common"
-	"strconv"
-	"strings"
-
 	"github.com/gin-gonic/gin"
-)
-
-type Message struct {
-	Role    string  `json:"role"`
-	Content any     `json:"content"`
-	Name    *string `json:"name,omitempty"`
-}
-
-type VisionMessage struct {
-	Role    string                       `json:"role"`
-	Content []OpenaiVisionMessageContent `json:"content"`
-	Name    *string                      `json:"name,omitempty"`
-}
-
-// OpenaiVisionMessageContentType vision message content type
-type OpenaiVisionMessageContentType string
-
-const (
-	// OpenaiVisionMessageContentTypeText text
-	OpenaiVisionMessageContentTypeText OpenaiVisionMessageContentType = "text"
-	// OpenaiVisionMessageContentTypeImageUrl image url
-	OpenaiVisionMessageContentTypeImageUrl OpenaiVisionMessageContentType = "image_url"
-)
-
-// OpenaiVisionMessageContent vision message content
-type OpenaiVisionMessageContent struct {
-	Type     OpenaiVisionMessageContentType     `json:"type"`
-	Text     string                             `json:"text,omitempty"`
-	ImageUrl OpenaiVisionMessageContentImageUrl `json:"image_url,omitempty"`
-}
-
-// VisionImageResolution image resolution
-type VisionImageResolution string
-
-const (
-	// VisionImageResolutionLow low resolution
-	VisionImageResolutionLow VisionImageResolution = "low"
-	// VisionImageResolutionHigh high resolution
-	VisionImageResolutionHigh VisionImageResolution = "high"
-)
-
-type OpenaiVisionMessageContentImageUrl struct {
-	URL    string                `json:"url"`
-	Detail VisionImageResolution `json:"detail,omitempty"`
-}
-
-type ImageURL struct {
-	Url    string `json:"url,omitempty"`
-	Detail string `json:"detail,omitempty"`
-}
-
-type TextContent struct {
-	Type string `json:"type,omitempty"`
-	Text string `json:"text,omitempty"`
-}
-
-type ImageContent struct {
-	Type     string    `json:"type,omitempty"`
-	ImageURL *ImageURL `json:"image_url,omitempty"`
-}
-
-const (
-	ContentTypeText     = "text"
-	ContentTypeImageURL = "image_url"
-)
-
-type OpenAIMessageContent struct {
-	Type     string    `json:"type,omitempty"`
-	Text     string    `json:"text"`
-	ImageURL *ImageURL `json:"image_url,omitempty"`
-}
-
-func (m Message) IsStringContent() bool {
-	_, ok := m.Content.(string)
-	return ok
-}
-
-func (m Message) StringContent() string {
-	content, ok := m.Content.(string)
-	if ok {
-		return content
-	}
-	contentList, ok := m.Content.([]any)
-	if ok {
-		var contentStr string
-		for _, contentItem := range contentList {
-			contentMap, ok := contentItem.(map[string]any)
-			if !ok {
-				continue
-			}
-			if contentMap["type"] == ContentTypeText {
-				if subStr, ok := contentMap["text"].(string); ok {
-					contentStr += subStr
-				}
-			}
-		}
-		return contentStr
-	}
-	return ""
-}
-
-func (m Message) ParseContent() []OpenAIMessageContent {
-	var contentList []OpenAIMessageContent
-	content, ok := m.Content.(string)
-	if ok {
-		contentList = append(contentList, OpenAIMessageContent{
-			Type: ContentTypeText,
-			Text: content,
-		})
-		return contentList
-	}
-	anyList, ok := m.Content.([]any)
-	if ok {
-		for _, contentItem := range anyList {
-			contentMap, ok := contentItem.(map[string]any)
-			if !ok {
-				continue
-			}
-			switch contentMap["type"] {
-			case ContentTypeText:
-				if subStr, ok := contentMap["text"].(string); ok {
-					contentList = append(contentList, OpenAIMessageContent{
-						Type: ContentTypeText,
-						Text: subStr,
-					})
-				}
-			case ContentTypeImageURL:
-				if subObj, ok := contentMap["image_url"].(map[string]any); ok {
-					contentList = append(contentList, OpenAIMessageContent{
-						Type: ContentTypeImageURL,
-						ImageURL: &ImageURL{
-							Url: subObj["url"].(string),
-						},
-					})
-				}
-			}
-		}
-		return contentList
-	}
-	return nil
-}
-
-const (
-	RelayModeUnknown = iota
-	RelayModeChatCompletions
-	RelayModeCompletions
-	RelayModeEmbeddings
-	RelayModeModerations
-	RelayModeImagesGenerations
-	RelayModeEdits
-	RelayModeAudioSpeech
-	RelayModeAudioTranscription
-	RelayModeAudioTranslation
+	"github.com/songquanpeng/one-api/common/config"
+	"github.com/songquanpeng/one-api/common/helper"
+	"github.com/songquanpeng/one-api/common/logger"
+	"github.com/songquanpeng/one-api/relay/channel/openai"
+	"github.com/songquanpeng/one-api/relay/constant"
+	"github.com/songquanpeng/one-api/relay/controller"
+	"github.com/songquanpeng/one-api/relay/util"
+	"net/http"
+	"strconv"
 )
 
 // https://platform.openai.com/docs/api-reference/chat
 
-type ResponseFormat struct {
-	Type string `json:"type,omitempty"`
-}
-
-type GeneralOpenAIRequest struct {
-	Model            string          `json:"model,omitempty"`
-	Messages         []Message       `json:"messages,omitempty"`
-	Prompt           any             `json:"prompt,omitempty"`
-	Stream           bool            `json:"stream,omitempty"`
-	MaxTokens        int             `json:"max_tokens,omitempty"`
-	Temperature      float64         `json:"temperature,omitempty"`
-	TopP             float64         `json:"top_p,omitempty"`
-	N                int             `json:"n,omitempty"`
-	Input            any             `json:"input,omitempty"`
-	Instruction      string          `json:"instruction,omitempty"`
-	Size             string          `json:"size,omitempty"`
-	Functions        any             `json:"functions,omitempty"`
-	FrequencyPenalty float64         `json:"frequency_penalty,omitempty"`
-	PresencePenalty  float64         `json:"presence_penalty,omitempty"`
-	ResponseFormat   *ResponseFormat `json:"response_format,omitempty"`
-	Seed             float64         `json:"seed,omitempty"`
-	Tools            any             `json:"tools,omitempty"`
-	ToolChoice       any             `json:"tool_choice,omitempty"`
-	User             string          `json:"user,omitempty"`
-}
-
-// func (r *GeneralOpenAIRequest) MessagesLen() int {
-// 	switch msgs := r.Messages.(type) {
-// 	case []any:
-// 		return len(msgs)
-// 	case []Message:
-// 		return len(msgs)
-// 	case []VisionMessage:
-// 		return len(msgs)
-// 	case []map[string]any:
-// 		return len(msgs)
-// 	default:
-// 		return 0
-// 	}
-// }
-
-// TextMessages returns messages as []Message
-// func (r *GeneralOpenAIRequest) TextMessages() (messages []Message, err error) {
-// 	if blob, err := json.Marshal(r.Messages); err != nil {
-// 		return nil, errors.Wrap(err, "marshal messages failed")
-// 	} else if err := json.Unmarshal(blob, &messages); err != nil {
-// 		return nil, errors.Wrapf(err, "unmarshal messages failed %q", string(blob))
-// 	} else {
-// 		return messages, nil
-// 	}
-// }
-
-// VisionMessages returns messages as []VisionMessage
-// func (r *GeneralOpenAIRequest) VisionMessages() (messages []VisionMessage, err error) {
-// 	if blob, err := json.Marshal(r.Messages); err != nil {
-// 		return nil, errors.Wrap(err, "marshal vision messages failed")
-// 	} else if err := json.Unmarshal(blob, &messages); err != nil {
-// 		return nil, errors.Wrapf(err, "unmarshal vision messages failed %q", string(blob))
-// 	} else {
-// 		return messages, nil
-// 	}
-// }
-
-func (r GeneralOpenAIRequest) ParseInput() []string {
-	if r.Input == nil {
-		return nil
-	}
-	var input []string
-	switch r.Input.(type) {
-	case string:
-		input = []string{r.Input.(string)}
-	case []any:
-		input = make([]string, 0, len(r.Input.([]any)))
-		for _, item := range r.Input.([]any) {
-			if str, ok := item.(string); ok {
-				input = append(input, str)
-			}
-		}
-	}
-	return input
-}
-
-type ChatRequest struct {
-	Model     string    `json:"model"`
-	Messages  []Message `json:"messages"`
-	MaxTokens int       `json:"max_tokens"`
-}
-
-type TextRequest struct {
-	Model     string    `json:"model"`
-	Messages  []Message `json:"messages"`
-	Prompt    string    `json:"prompt"`
-	MaxTokens int       `json:"max_tokens"`
-	//Stream   bool      `json:"stream"`
-}
-
-// ImageRequest docs: https://platform.openai.com/docs/api-reference/images/create
-type ImageRequest struct {
-	Model          string `json:"model"`
-	Prompt         string `json:"prompt" binding:"required"`
-	N              int    `json:"n,omitempty"`
-	Size           string `json:"size,omitempty"`
-	Quality        string `json:"quality,omitempty"`
-	ResponseFormat string `json:"response_format,omitempty"`
-	Style          string `json:"style,omitempty"`
-	User           string `json:"user,omitempty"`
-}
-
-type WhisperJSONResponse struct {
-	Text string `json:"text,omitempty"`
-}
-
-type WhisperVerboseJSONResponse struct {
-	Task     string    `json:"task,omitempty"`
-	Language string    `json:"language,omitempty"`
-	Duration float64   `json:"duration,omitempty"`
-	Text     string    `json:"text,omitempty"`
-	Segments []Segment `json:"segments,omitempty"`
-}
-
-type Segment struct {
-	Id               int     `json:"id"`
-	Seek             int     `json:"seek"`
-	Start            float64 `json:"start"`
-	End              float64 `json:"end"`
-	Text             string  `json:"text"`
-	Tokens           []int   `json:"tokens"`
-	Temperature      float64 `json:"temperature"`
-	AvgLogprob       float64 `json:"avg_logprob"`
-	CompressionRatio float64 `json:"compression_ratio"`
-	NoSpeechProb     float64 `json:"no_speech_prob"`
-}
-
-type TextToSpeechRequest struct {
-	Model          string  `json:"model" binding:"required"`
-	Input          string  `json:"input" binding:"required"`
-	Voice          string  `json:"voice" binding:"required"`
-	Speed          float64 `json:"speed"`
-	ResponseFormat string  `json:"response_format"`
-}
-
-type Usage struct {
-	PromptTokens     int `json:"prompt_tokens"`
-	CompletionTokens int `json:"completion_tokens"`
-	TotalTokens      int `json:"total_tokens"`
-}
-
-type OpenAIError struct {
-	Message string `json:"message"`
-	Type    string `json:"type"`
-	Param   string `json:"param"`
-	Code    any    `json:"code"`
-}
-
-type OpenAIErrorWithStatusCode struct {
-	OpenAIError
-	StatusCode int `json:"status_code"`
-}
-
-type TextResponse struct {
-	Choices []OpenAITextResponseChoice `json:"choices"`
-	Usage   `json:"usage"`
-	Error   OpenAIError `json:"error"`
-	Content string      `json:"-"`
-}
-
-type OpenAITextResponseChoice struct {
-	Index        int `json:"index"`
-	Message      `json:"message"`
-	FinishReason string `json:"finish_reason"`
-}
-
-type OpenAITextResponse struct {
-	Id      string                     `json:"id"`
-	Model   string                     `json:"model,omitempty"`
-	Object  string                     `json:"object"`
-	Created int64                      `json:"created"`
-	Choices []OpenAITextResponseChoice `json:"choices"`
-	Usage   `json:"usage"`
-}
-
-type OpenAIEmbeddingResponseItem struct {
-	Object    string    `json:"object"`
-	Index     int       `json:"index"`
-	Embedding []float64 `json:"embedding"`
-}
-
-type OpenAIEmbeddingResponse struct {
-	Object string                        `json:"object"`
-	Data   []OpenAIEmbeddingResponseItem `json:"data"`
-	Model  string                        `json:"model"`
-	Usage  `json:"usage"`
-}
-
-type ImageResponse struct {
-	Created int `json:"created"`
-	Data    []struct {
-		Url string `json:"url"`
-	}
-}
-
-type ChatCompletionsStreamResponseChoice struct {
-	Delta struct {
-		Content string `json:"content"`
-	} `json:"delta"`
-	FinishReason *string `json:"finish_reason,omitempty"`
-}
-
-type ChatCompletionsStreamResponse struct {
-	Id      string                                `json:"id"`
-	Object  string                                `json:"object"`
-	Created int64                                 `json:"created"`
-	Model   string                                `json:"model"`
-	Choices []ChatCompletionsStreamResponseChoice `json:"choices"`
-}
-
-type CompletionsStreamResponse struct {
-	Choices []struct {
-		Text         string `json:"text"`
-		FinishReason string `json:"finish_reason"`
-	} `json:"choices"`
-}
-
 func Relay(c *gin.Context) {
-	relayMode := RelayModeUnknown
-	if strings.HasPrefix(c.Request.URL.Path, "/v1/chat/completions") {
-		relayMode = RelayModeChatCompletions
-	} else if strings.HasPrefix(c.Request.URL.Path, "/v1/completions") {
-		relayMode = RelayModeCompletions
-	} else if strings.HasPrefix(c.Request.URL.Path, "/v1/embeddings") {
-		relayMode = RelayModeEmbeddings
-	} else if strings.HasSuffix(c.Request.URL.Path, "embeddings") {
-		relayMode = RelayModeEmbeddings
-	} else if strings.HasPrefix(c.Request.URL.Path, "/v1/moderations") {
-		relayMode = RelayModeModerations
-	} else if strings.HasPrefix(c.Request.URL.Path, "/v1/images/generations") {
-		relayMode = RelayModeImagesGenerations
-	} else if strings.HasPrefix(c.Request.URL.Path, "/v1/edits") {
-		relayMode = RelayModeEdits
-	} else if strings.HasPrefix(c.Request.URL.Path, "/v1/audio/speech") {
-		relayMode = RelayModeAudioSpeech
-	} else if strings.HasPrefix(c.Request.URL.Path, "/v1/audio/transcriptions") {
-		relayMode = RelayModeAudioTranscription
-	} else if strings.HasPrefix(c.Request.URL.Path, "/v1/audio/translations") {
-		relayMode = RelayModeAudioTranslation
-	}
-	var err *OpenAIErrorWithStatusCode
+	relayMode := constant.Path2RelayMode(c.Request.URL.Path)
+	var err *openai.ErrorWithStatusCode
 	switch relayMode {
-	case RelayModeImagesGenerations:
-		err = relayImageHelper(c, relayMode)
-	case RelayModeAudioSpeech:
+	case constant.RelayModeImagesGenerations:
+		err = controller.RelayImageHelper(c, relayMode)
+	case constant.RelayModeAudioSpeech:
 		fallthrough
-	case RelayModeAudioTranslation:
+	case constant.RelayModeAudioTranslation:
 		fallthrough
-	case RelayModeAudioTranscription:
-		err = relayAudioHelper(c, relayMode)
+	case constant.RelayModeAudioTranscription:
+		err = controller.RelayAudioHelper(c, relayMode)
 	default:
-		err = relayTextHelper(c, relayMode)
+		err = controller.RelayTextHelper(c)
 	}
 	if err != nil {
-		requestId := c.GetString(common.RequestIdKey)
+		requestId := c.GetString(logger.RequestIdKey)
 		retryTimesStr := c.Query("retry")
 		retryTimes, _ := strconv.Atoi(retryTimesStr)
 		if retryTimesStr == "" {
-			retryTimes = common.RetryTimes
+			retryTimes = config.RetryTimes
 		}
 		if retryTimes > 0 {
 			c.Redirect(http.StatusTemporaryRedirect, fmt.Sprintf("%s?retry=%d", c.Request.URL.Path, retryTimes-1))
 		} else {
 			if err.StatusCode == http.StatusTooManyRequests {
-				err.OpenAIError.Message = "当前分组上游负载已饱和，请稍后再试"
+				err.Error.Message = "当前分组上游负载已饱和，请稍后再试"
 			}
-			err.OpenAIError.Message = common.MessageWithRequestId(err.OpenAIError.Message, requestId)
+			err.Error.Message = helper.MessageWithRequestId(err.Error.Message, requestId)
 			c.JSON(err.StatusCode, gin.H{
-				"error": err.OpenAIError,
+				"error": err.Error,
 			})
 		}
 		channelId := c.GetInt("channel_id")
-		common.LogError(c.Request.Context(), fmt.Sprintf("relay error (channel #%d): %+v", channelId, err))
+		logger.Error(c.Request.Context(), fmt.Sprintf("relay error (channel #%d): %s", channelId, err.Message))
 		// https://platform.openai.com/docs/guides/error-codes/api-errors
-		if shouldDisableChannel(&err.OpenAIError, err.StatusCode) {
+		if util.ShouldDisableChannel(&err.Error, err.StatusCode) {
 			channelId := c.GetInt("channel_id")
 			channelName := c.GetString("channel_name")
 			disableChannel(channelId, channelName, err.Message)
@@ -454,7 +61,7 @@ func Relay(c *gin.Context) {
 }
 
 func RelayNotImplemented(c *gin.Context) {
-	err := OpenAIError{
+	err := openai.Error{
 		Message: "API not implemented",
 		Type:    "one_api_error",
 		Param:   "",
@@ -466,7 +73,7 @@ func RelayNotImplemented(c *gin.Context) {
 }
 
 func RelayNotFound(c *gin.Context) {
-	err := OpenAIError{
+	err := openai.Error{
 		Message: fmt.Sprintf("Invalid URL (%s %s)", c.Request.Method, c.Request.URL.Path),
 		Type:    "invalid_request_error",
 		Param:   "",

controller/relay_test.go

@@ -1,46 +0,0 @@
-package controller
-
-import (
-	"encoding/json"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestGeneralOpenAIRequest_TextMessages(t *testing.T) {
-	tests := []struct {
-		name     string
-		messages []Message
-		want     []Message
-		wantErr  error
-	}{
-		{
-			name:     "Test with []any messages",
-			messages: []Message{{}, {}},
-			want:     []Message{{}, {}},
-			wantErr:  nil,
-		},
-		{
-			name:     "Test with []Message messages",
-			messages: []Message{{}, {}},
-			want:     []Message{{}, {}},
-			wantErr:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			r := &GeneralOpenAIRequest{
-				Messages: tt.messages,
-			}
-			got := new(GeneralOpenAIRequest)
-
-			blob, err := json.Marshal(r)
-			require.NoError(t, err)
-			err = json.Unmarshal(blob, got)
-			require.NoError(t, err)
-
-			require.Equal(t, tt.want, got.Messages)
-		})
-	}
-}

controller/token.go

@@ -3,11 +3,13 @@ package controller
 import (
 	"fmt"
 	"net/http"
-	"one-api/common"
-	"one-api/model"
 	"strconv"
 
 	"github.com/gin-gonic/gin"
+	"github.com/songquanpeng/one-api/common"
+	"github.com/songquanpeng/one-api/common/config"
+	"github.com/songquanpeng/one-api/common/helper"
+	"github.com/songquanpeng/one-api/model"
 )
 
 func GetAllTokens(c *gin.Context) {
@@ -16,7 +18,7 @@ func GetAllTokens(c *gin.Context) {
 	if p < 0 {
 		p = 0
 	}
-	tokens, err := model.GetAllUserTokens(userId, p*common.ItemsPerPage, common.ItemsPerPage)
+	tokens, err := model.GetAllUserTokens(userId, p*config.ItemsPerPage, config.ItemsPerPage)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
@@ -121,9 +123,9 @@ func AddToken(c *gin.Context) {
 	cleanToken := model.Token{
 		UserId:         c.GetInt("id"),
 		Name:           token.Name,
-		Key:            common.GenerateKey(),
-		CreatedTime:    common.GetTimestamp(),
-		AccessedTime:   common.GetTimestamp(),
+		Key:            helper.GenerateKey(),
+		CreatedTime:    helper.GetTimestamp(),
+		AccessedTime:   helper.GetTimestamp(),
 		ExpiredTime:    token.ExpiredTime,
 		RemainQuota:    token.RemainQuota,
 		UnlimitedQuota: token.UnlimitedQuota,
@@ -194,7 +196,7 @@ func UpdateToken(c *gin.Context) {
 		return
 	}
 
-	cleanToken, err := model.GetTokenByIds(tokenPatch.Id, userId)
+	tokenInDB, err := model.GetTokenByIds(tokenPatch.Id, userId)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
@@ -204,18 +206,16 @@ func UpdateToken(c *gin.Context) {
 	}
 
 	if tokenPatch.Status == common.TokenStatusEnabled {
-		if cleanToken.Status == common.TokenStatusExpired &&
-			cleanToken.ExpiredTime <= common.GetTimestamp() &&
-			cleanToken.ExpiredTime != -1 {
+		if tokenInDB.Status == common.TokenStatusExpired && tokenInDB.ExpiredTime <= helper.GetTimestamp() && tokenInDB.ExpiredTime != -1 {
 			c.JSON(http.StatusOK, gin.H{
 				"success": false,
 				"message": "令牌已过期，无法启用，请先修改令牌过期时间，或者设置为永不过期",
 			})
 			return
 		}
-		if cleanToken.Status == common.TokenStatusExhausted &&
-			cleanToken.RemainQuota <= 0 &&
-			!cleanToken.UnlimitedQuota {
+		if tokenInDB.Status == common.TokenStatusExhausted &&
+			tokenInDB.RemainQuota <= 0 &&
+			!tokenInDB.UnlimitedQuota {
 			c.JSON(http.StatusOK, gin.H{
 				"success": false,
 				"message": "令牌可用额度已用尽，无法启用，请先修改令牌剩余额度，或者设置为无限额度",
@@ -224,31 +224,31 @@ func UpdateToken(c *gin.Context) {
 		}
 	}
 	if statusOnly != "" {
-		cleanToken.Status = tokenPatch.Status
+		tokenInDB.Status = tokenPatch.Status
 	} else {
 		// If you add more fields, please also update tokenPatch.Update()
 		if tokenPatch.Name != nil {
-			cleanToken.Name = *tokenPatch.Name
+			tokenInDB.Name = *tokenPatch.Name
 		}
 		if tokenPatch.ExpiredTime != nil {
-			cleanToken.ExpiredTime = *tokenPatch.ExpiredTime
+			tokenInDB.ExpiredTime = *tokenPatch.ExpiredTime
 		}
 		if tokenPatch.RemainQuota != nil {
-			cleanToken.RemainQuota = *tokenPatch.RemainQuota
+			tokenInDB.RemainQuota = *tokenPatch.RemainQuota
 		}
 		if tokenPatch.UnlimitedQuota != nil {
-			cleanToken.UnlimitedQuota = *tokenPatch.UnlimitedQuota
+			tokenInDB.UnlimitedQuota = *tokenPatch.UnlimitedQuota
 		}
 	}
 
-	cleanToken.RemainQuota -= tokenPatch.AddUsedQuota
-	cleanToken.UsedQuota += tokenPatch.AddUsedQuota
+	tokenInDB.RemainQuota -= tokenPatch.AddUsedQuota
+	tokenInDB.UsedQuota += tokenPatch.AddUsedQuota
 
 	if tokenPatch.AddUsedQuota != 0 {
 		model.RecordLog(userId, model.LogTypeConsume, fmt.Sprintf("外部(%s)消耗 %s", tokenPatch.AddReason, common.LogQuota(tokenPatch.AddUsedQuota)))
 	}
 
-	if err = cleanToken.Update(); err != nil {
+	if err = tokenInDB.Update(); err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
 			"message": "update token: " + err.Error(),
@@ -259,7 +259,7 @@ func UpdateToken(c *gin.Context) {
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
 		"message": "",
-		"data":    cleanToken,
+		"data":    tokenInDB,
 	})
 	return
 }

controller/user.go

@@ -3,9 +3,11 @@ package controller
 import (
 	"encoding/json"
 	"fmt"
+	"github.com/songquanpeng/one-api/common"
+	"github.com/songquanpeng/one-api/common/config"
+	"github.com/songquanpeng/one-api/common/helper"
+	"github.com/songquanpeng/one-api/model"
 	"net/http"
-	"one-api/common"
-	"one-api/model"
 	"strconv"
 	"time"
 
@@ -19,7 +21,7 @@ type LoginRequest struct {
 }
 
 func Login(c *gin.Context) {
-	if !common.PasswordLoginEnabled {
+	if !config.PasswordLoginEnabled {
 		c.JSON(http.StatusOK, gin.H{
 			"message": "管理员关闭了密码登录",
 			"success": false,
@@ -106,14 +108,14 @@ func Logout(c *gin.Context) {
 }
 
 func Register(c *gin.Context) {
-	if !common.RegisterEnabled {
+	if !config.RegisterEnabled {
 		c.JSON(http.StatusOK, gin.H{
 			"message": "管理员关闭了新用户注册",
 			"success": false,
 		})
 		return
 	}
-	if !common.PasswordRegisterEnabled {
+	if !config.PasswordRegisterEnabled {
 		c.JSON(http.StatusOK, gin.H{
 			"message": "管理员关闭了通过密码进行注册，请使用第三方账户验证的形式进行注册",
 			"success": false,
@@ -136,7 +138,7 @@ func Register(c *gin.Context) {
 		})
 		return
 	}
-	if common.EmailVerificationEnabled {
+	if config.EmailVerificationEnabled {
 		if user.Email == "" || user.VerificationCode == "" {
 			c.JSON(http.StatusOK, gin.H{
 				"success": false,
@@ -160,7 +162,7 @@ func Register(c *gin.Context) {
 		DisplayName: user.Username,
 		InviterId:   inviterId,
 	}
-	if common.EmailVerificationEnabled {
+	if config.EmailVerificationEnabled {
 		cleanUser.Email = user.Email
 	}
 	if err := cleanUser.Insert(inviterId); err != nil {
@@ -182,7 +184,7 @@ func GetAllUsers(c *gin.Context) {
 	if p < 0 {
 		p = 0
 	}
-	users, err := model.GetAllUsers(p*common.ItemsPerPage, common.ItemsPerPage)
+	users, err := model.GetAllUsers(p*config.ItemsPerPage, config.ItemsPerPage)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
@@ -282,7 +284,7 @@ func GenerateAccessToken(c *gin.Context) {
 		})
 		return
 	}
-	user.AccessToken = common.GetUUID()
+	user.AccessToken = helper.GetUUID()
 
 	if model.DB.Where("access_token = ?", user.AccessToken).First(user).RowsAffected != 0 {
 		c.JSON(http.StatusOK, gin.H{
@@ -319,7 +321,7 @@ func GetAffCode(c *gin.Context) {
 		return
 	}
 	if user.AffCode == "" {
-		user.AffCode = common.GetRandomString(4)
+		user.AffCode = helper.GetRandomString(4)
 		if err := user.Update(false); err != nil {
 			c.JSON(http.StatusOK, gin.H{
 				"success": false,
@@ -736,7 +738,7 @@ func EmailBind(c *gin.Context) {
 		return
 	}
 	if user.Role == common.RoleRootUser {
-		common.RootUserEmail = email
+		config.RootUserEmail = email
 	}
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,

controller/wechat.go

@@ -5,9 +5,10 @@ import (
 	"errors"
 	"fmt"
 	"github.com/gin-gonic/gin"
+	"github.com/songquanpeng/one-api/common"
+	"github.com/songquanpeng/one-api/common/config"
+	"github.com/songquanpeng/one-api/model"
 	"net/http"
-	"one-api/common"
-	"one-api/model"
 	"strconv"
 	"time"
 )
@@ -22,11 +23,11 @@ func getWeChatIdByCode(code string) (string, error) {
 	if code == "" {
 		return "", errors.New("无效的参数")
 	}
-	req, err := http.NewRequest("GET", fmt.Sprintf("%s/api/wechat/user?code=%s", common.WeChatServerAddress, code), nil)
+	req, err := http.NewRequest("GET", fmt.Sprintf("%s/api/wechat/user?code=%s", config.WeChatServerAddress, code), nil)
 	if err != nil {
 		return "", err
 	}
-	req.Header.Set("Authorization", common.WeChatServerToken)
+	req.Header.Set("Authorization", config.WeChatServerToken)
 	client := http.Client{
 		Timeout: 5 * time.Second,
 	}
@@ -50,7 +51,7 @@ func getWeChatIdByCode(code string) (string, error) {
 }
 
 func WeChatAuth(c *gin.Context) {
-	if !common.WeChatAuthEnabled {
+	if !config.WeChatAuthEnabled {
 		c.JSON(http.StatusOK, gin.H{
 			"message": "管理员未开启通过微信登录以及注册",
 			"success": false,
@@ -79,7 +80,7 @@ func WeChatAuth(c *gin.Context) {
 			return
 		}
 	} else {
-		if common.RegisterEnabled {
+		if config.RegisterEnabled {
 			user.Username = "wechat_" + strconv.Itoa(model.GetMaxUserId()+1)
 			user.DisplayName = "WeChat User"
 			user.Role = common.RoleCommonUser
@@ -112,7 +113,7 @@ func WeChatAuth(c *gin.Context) {
 }
 
 func WeChatBind(c *gin.Context) {
-	if !common.WeChatAuthEnabled {
+	if !config.WeChatAuthEnabled {
 		c.JSON(http.StatusOK, gin.H{
 			"message": "管理员未开启通过微信登录以及注册",
 			"success": false,