chore: Remove unused pipelines and triggers.

.github/workflows/docker-image-amd64-en.yml

@@ -1,49 +0,0 @@
-name: Publish Docker image (amd64, English)
-
-on:
-  push:
-    tags:
-      - '*'
-  workflow_dispatch:
-    inputs:
-      name:
-        description: 'reason'
-        required: false
-jobs:
-  push_to_registries:
-    name: Push Docker image to multiple registries
-    runs-on: ubuntu-latest
-    permissions:
-      packages: write
-      contents: read
-    steps:
-      - name: Check out the repo
-        uses: actions/checkout@v3
-
-      - name: Save version info
-        run: |
-          git describe --tags > VERSION 
-
-      - name: Translate
-        run: |
-          python ./i18n/translate.py --repository_path . --json_file_path ./i18n/en.json
-      - name: Log in to Docker Hub
-        uses: docker/login-action@v2
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@v4
-        with:
-          images: |
-            justsong/one-api-en
-
-      - name: Build and push Docker images
-        uses: docker/build-push-action@v3
-        with:
-          context: .
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}

.github/workflows/docker-image-amd64.yml

@@ -1,34 +1,28 @@
 name: Publish Docker image (amd64)
 
 on:
-  push:
-    tags:
-      - '*'
   workflow_dispatch:
     inputs:
       name:
         description: 'reason'
         required: false
+
 jobs:
-  push_to_registries:
-    name: Push Docker image to multiple registries
+  build-and-push-image:
+    name: Push Docker image to GitHub registry
     runs-on: ubuntu-latest
     permissions:
       packages: write
       contents: read
+
     steps:
+
       - name: Check out the repo
         uses: actions/checkout@v3
 
       - name: Save version info
         run: |
-          git describe --tags > VERSION 
-
-      - name: Log in to Docker Hub
-        uses: docker/login-action@v2
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
+          git describe --tags > VERSION
 
       - name: Log in to the Container registry
         uses: docker/login-action@v2
@@ -41,9 +35,7 @@ jobs:
         id: meta
         uses: docker/metadata-action@v4
         with:
-          images: |
-            justsong/one-api
-            ghcr.io/${{ github.repository }}
+          images: ghcr.io/${{ github.repository }}
 
       - name: Build and push Docker images
         uses: docker/build-push-action@v3

.github/workflows/docker-image-arm64.yml

@@ -1,62 +0,0 @@
-name: Publish Docker image (arm64)
-
-on:
-  push:
-    tags:
-      - '*'
-      - '!*-alpha*'
-  workflow_dispatch:
-    inputs:
-      name:
-        description: 'reason'
-        required: false
-jobs:
-  push_to_registries:
-    name: Push Docker image to multiple registries
-    runs-on: ubuntu-latest
-    permissions:
-      packages: write
-      contents: read
-    steps:
-      - name: Check out the repo
-        uses: actions/checkout@v3
-
-      - name: Save version info
-        run: |
-          git describe --tags > VERSION 
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-
-      - name: Log in to Docker Hub
-        uses: docker/login-action@v2
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Log in to the Container registry
-        uses: docker/login-action@v2
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@v4
-        with:
-          images: |
-            justsong/one-api
-            ghcr.io/${{ github.repository }}
-
-      - name: Build and push Docker images
-        uses: docker/build-push-action@v3
-        with:
-          context: .
-          platforms: linux/amd64,linux/arm64
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}

.github/workflows/linux-release.yml

@@ -1,59 +0,0 @@
-name: Linux Release
-permissions:
-  contents: write
-
-on:
-  push:
-    tags:
-      - '*'
-      - '!*-alpha*'
-  workflow_dispatch:
-    inputs:
-      name:
-        description: 'reason'
-        required: false
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 16
-      - name: Build Frontend (theme default)
-        env:
-          CI: ""
-        run: |
-          cd web
-          git describe --tags > VERSION
-          REACT_APP_VERSION=$(git describe --tags) chmod u+x ./build.sh && ./build.sh
-          cd ..
-      - name: Set up Go
-        uses: actions/setup-go@v3
-        with:
-          go-version: '>=1.18.0'
-      - name: Build Backend (amd64)
-        run: |
-          go mod download
-          go build -ldflags "-s -w -X 'one-api/common.Version=$(git describe --tags)' -extldflags '-static'" -o one-api
-
-      - name: Build Backend (arm64)
-        run: |
-          sudo apt-get update
-          sudo apt-get install gcc-aarch64-linux-gnu
-          CC=aarch64-linux-gnu-gcc CGO_ENABLED=1 GOOS=linux GOARCH=arm64 go build -ldflags "-s -w -X 'one-api/common.Version=$(git describe --tags)' -extldflags '-static'" -o one-api-arm64
-
-      - name: Release
-        uses: softprops/action-gh-release@v1
-        if: startsWith(github.ref, 'refs/tags/')
-        with:
-          files: |
-            one-api
-            one-api-arm64
-          draft: true
-          generate_release_notes: true
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/macos-release.yml

@@ -1,50 +0,0 @@
-name: macOS Release
-permissions:
-  contents: write
-
-on:
-  push:
-    tags:
-      - '*'
-      - '!*-alpha*'
-  workflow_dispatch:
-    inputs:
-      name:
-        description: 'reason'
-        required: false
-jobs:
-  release:
-    runs-on: macos-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 16
-      - name: Build Frontend (theme default)
-        env:
-          CI: ""
-        run: |
-          cd web
-          git describe --tags > VERSION
-          REACT_APP_VERSION=$(git describe --tags) chmod u+x ./build.sh && ./build.sh
-          cd ..
-      - name: Set up Go
-        uses: actions/setup-go@v3
-        with:
-          go-version: '>=1.18.0'
-      - name: Build Backend
-        run: |
-          go mod download
-          go build -ldflags "-X 'one-api/common.Version=$(git describe --tags)'" -o one-api-macos
-      - name: Release
-        uses: softprops/action-gh-release@v1
-        if: startsWith(github.ref, 'refs/tags/')
-        with:
-          files: one-api-macos
-          draft: true
-          generate_release_notes: true
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/windows-release.yml

@@ -1,53 +0,0 @@
-name: Windows Release
-permissions:
-  contents: write
-
-on:
-  push:
-    tags:
-      - '*'
-      - '!*-alpha*'
-  workflow_dispatch:
-    inputs:
-      name:
-        description: 'reason'
-        required: false
-jobs:
-  release:
-    runs-on: windows-latest
-    defaults:
-      run:
-        shell: bash
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 16
-      - name: Build Frontend (theme default)
-        env:
-          CI: ""
-        run: |
-          cd web/default
-          npm install
-          REACT_APP_VERSION=$(git describe --tags) npm run build
-          cd ../..
-      - name: Set up Go
-        uses: actions/setup-go@v3
-        with:
-          go-version: '>=1.18.0'
-      - name: Build Backend
-        run: |
-          go mod download
-          go build -ldflags "-s -w -X 'one-api/common.Version=$(git describe --tags)'" -o one-api.exe
-      - name: Release
-        uses: softprops/action-gh-release@v1
-        if: startsWith(github.ref, 'refs/tags/')
-        with:
-          files: one-api.exe
-          draft: true
-          generate_release_notes: true
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

README.md

@@ -414,9 +414,6 @@ https://openai.justsong.cn
 8. 升级之前数据库需要做变更吗？
    + 一般情况下不需要，系统将在初始化的时候自动调整。
    + 如果需要的话，我会在更新日志中说明，并给出脚本。
-9. 手动修改数据库后报错：`数据库一致性已被破坏，请联系管理员`？
-   + 这是检测到 ability 表里有些记录的通道 id 是不存在的，这大概率是因为你删了 channel 表里的记录但是没有同步在 ability 表里清理无效的通道。
-   + 对于每一个通道，其所支持的模型都需要有一个专门的 ability 表的记录，表示该通道支持该模型。
 
 ## 相关项目
 * [FastGPT](https://github.com/labring/FastGPT): 基于 LLM 大语言模型的知识库问答系统

common/constants.go

@@ -62,6 +62,7 @@ var SMTPPort = 587
 var SMTPAccount = ""
 var SMTPFrom = ""
 var SMTPToken = ""
+var SMTPAuthLoginEnabled = false
 
 var GitHubClientId = ""
 var GitHubClientSecret = ""

common/email.go

@@ -4,12 +4,39 @@ import (
 	"crypto/rand"
 	"crypto/tls"
 	"encoding/base64"
+	"errors"
 	"fmt"
 	"net/smtp"
 	"strings"
 	"time"
 )
 
+type loginAuth struct {
+	username, password string
+}
+
+func LoginAuth(username, password string) smtp.Auth {
+	return &loginAuth{username, password}
+}
+
+func (a *loginAuth) Start(_ *smtp.ServerInfo) (string, []byte, error) {
+	return "LOGIN", []byte(a.username), nil
+}
+
+func (a *loginAuth) Next(fromServer []byte, more bool) ([]byte, error) {
+	if more {
+		switch string(fromServer) {
+		case "Username:":
+			return []byte(a.username), nil
+		case "Password:":
+			return []byte(a.password), nil
+		default:
+			return nil, errors.New("unknown command from server during login auth")
+		}
+	}
+	return nil, nil
+}
+
 func SendEmail(subject string, receiver string, content string) error {
 	if SMTPFrom == "" { // for compatibility
 		SMTPFrom = SMTPAccount
@@ -37,7 +64,13 @@ func SendEmail(subject string, receiver string, content string) error {
 		"Date: %s\r\n"+
 		"Content-Type: text/html; charset=UTF-8\r\n\r\n%s\r\n",
 		receiver, SystemName, SMTPFrom, encodedSubject, messageId, time.Now().Format(time.RFC1123Z), content))
-	auth := smtp.PlainAuth("", SMTPAccount, SMTPToken, SMTPServer)
+
+	var auth smtp.Auth
+	if SMTPAuthLoginEnabled {
+		auth = LoginAuth(SMTPAccount, SMTPToken)
+	} else {
+		auth = smtp.PlainAuth("", SMTPAccount, SMTPToken, SMTPServer)
+	}
 	addr := fmt.Sprintf("%s:%d", SMTPServer, SMTPPort)
 	to := strings.Split(receiver, ";")
 

common/gin.go

@@ -31,11 +31,3 @@ func UnmarshalBodyReusable(c *gin.Context, v any) error {
 	c.Request.Body = io.NopCloser(bytes.NewBuffer(requestBody))
 	return nil
 }
-
-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")
-}

controller/billing.go

@@ -4,7 +4,6 @@ import (
 	"github.com/gin-gonic/gin"
 	"one-api/common"
 	"one-api/model"
-	"one-api/relay/channel/openai"
 )
 
 func GetSubscription(c *gin.Context) {
@@ -28,12 +27,12 @@ func GetSubscription(c *gin.Context) {
 		expiredTime = 0
 	}
 	if err != nil {
-		Error := openai.Error{
+		openAIError := OpenAIError{
 			Message: err.Error(),
 			Type:    "upstream_error",
 		}
 		c.JSON(200, gin.H{
-			"error": Error,
+			"error": openAIError,
 		})
 		return
 	}
@@ -70,12 +69,12 @@ func GetUsage(c *gin.Context) {
 		quota, err = model.GetUserUsedQuota(userId)
 	}
 	if err != nil {
-		Error := openai.Error{
+		openAIError := OpenAIError{
 			Message: err.Error(),
 			Type:    "one_api_error",
 		}
 		c.JSON(200, gin.H{
-			"error": Error,
+			"error": openAIError,
 		})
 		return
 	}

controller/channel-billing.go

@@ -8,7 +8,6 @@ import (
 	"net/http"
 	"one-api/common"
 	"one-api/model"
-	"one-api/relay/util"
 	"strconv"
 	"time"
 
@@ -93,7 +92,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 := util.HTTPClient.Do(req)
+	res, err := httpClient.Do(req)
 	if err != nil {
 		return nil, err
 	}

controller/channel-test.go

@@ -9,8 +9,6 @@ import (
 	"net/http"
 	"one-api/common"
 	"one-api/model"
-	"one-api/relay/channel/openai"
-	"one-api/relay/util"
 	"strconv"
 	"sync"
 	"time"
@@ -18,7 +16,7 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-func testChannel(channel *model.Channel, request openai.ChatRequest) (err error, openaiErr *openai.Error) {
+func testChannel(channel *model.Channel, request ChatRequest) (err error, openaiErr *OpenAIError) {
 	switch channel.Type {
 	case common.ChannelTypePaLM:
 		fallthrough
@@ -48,13 +46,13 @@ func testChannel(channel *model.Channel, request openai.ChatRequest) (err error,
 	}
 	requestURL := common.ChannelBaseURLs[channel.Type]
 	if channel.Type == common.ChannelTypeAzure {
-		requestURL = util.GetFullRequestURL(channel.GetBaseURL(), fmt.Sprintf("/openai/deployments/%s/chat/completions?api-version=2023-03-15-preview", request.Model), channel.Type)
+		requestURL = 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 = util.GetFullRequestURL(requestURL, "/v1/chat/completions", channel.Type)
+		requestURL = getFullRequestURL(requestURL, "/v1/chat/completions", channel.Type)
 	}
 	jsonData, err := json.Marshal(request)
 	if err != nil {
@@ -70,12 +68,12 @@ func testChannel(channel *model.Channel, request openai.ChatRequest) (err error,
 		req.Header.Set("Authorization", "Bearer "+channel.Key)
 	}
 	req.Header.Set("Content-Type", "application/json")
-	resp, err := util.HTTPClient.Do(req)
+	resp, err := httpClient.Do(req)
 	if err != nil {
 		return err, nil
 	}
 	defer resp.Body.Close()
-	var response openai.SlimTextResponse
+	var response TextResponse
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return err, nil
@@ -93,12 +91,12 @@ func testChannel(channel *model.Channel, request openai.ChatRequest) (err error,
 	return nil, nil
 }
 
-func buildTestRequest() *openai.ChatRequest {
-	testRequest := &openai.ChatRequest{
+func buildTestRequest() *ChatRequest {
+	testRequest := &ChatRequest{
 		Model:     "", // this will be set later
 		MaxTokens: 1,
 	}
-	testMessage := openai.Message{
+	testMessage := Message{
 		Role:    "user",
 		Content: "hi",
 	}
@@ -206,10 +204,10 @@ 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 && util.ShouldDisableChannel(openaiErr, -1) {
+			if isChannelEnabled && shouldDisableChannel(openaiErr, -1) {
 				disableChannel(channel.Id, channel.Name, err.Error())
 			}
-			if !isChannelEnabled && util.ShouldEnableChannel(err, openaiErr) {
+			if !isChannelEnabled && shouldEnableChannel(err, openaiErr) {
 				enableChannel(channel.Id, channel.Name)
 			}
 			channel.UpdateResponseTime(milliseconds)

controller/log.go

@@ -6,8 +6,23 @@ import (
 	"one-api/common"
 	"one-api/model"
 	"strconv"
+	"strings"
 )
 
+func parseIntArray(input string) []int {
+	values := strings.Split(input, ",")
+	result := make([]int, 0)
+
+	for _, value := range values {
+		num, err := strconv.Atoi(strings.TrimSpace(value))
+		if err == nil {
+			result = append(result, num)
+		}
+	}
+
+	return result
+}
+
 func GetAllLogs(c *gin.Context) {
 	p, _ := strconv.Atoi(c.Query("p"))
 	if p < 0 {
@@ -19,8 +34,8 @@ func GetAllLogs(c *gin.Context) {
 	username := c.Query("username")
 	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)
+	channels := parseIntArray(c.Query("channel"))
+	logs, err := model.GetAllLogs(logType, startTimestamp, endTimestamp, modelName, username, tokenName, p*common.ItemsPerPage, common.ItemsPerPage, channels)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
@@ -107,8 +122,8 @@ func GetLogsStat(c *gin.Context) {
 	tokenName := c.Query("token_name")
 	username := c.Query("username")
 	modelName := c.Query("model_name")
-	channel, _ := strconv.Atoi(c.Query("channel"))
-	quotaNum := model.SumUsedQuota(logType, startTimestamp, endTimestamp, modelName, username, tokenName, channel)
+	channels := parseIntArray(c.Query("channel"))
+	quotaNum := model.SumUsedQuota(logType, startTimestamp, endTimestamp, modelName, username, tokenName, channels)
 	//tokenNum := model.SumUsedToken(logType, startTimestamp, endTimestamp, modelName, username, "")
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
@@ -128,8 +143,8 @@ func GetLogsSelfStat(c *gin.Context) {
 	endTimestamp, _ := strconv.ParseInt(c.Query("end_timestamp"), 10, 64)
 	tokenName := c.Query("token_name")
 	modelName := c.Query("model_name")
-	channel, _ := strconv.Atoi(c.Query("channel"))
-	quotaNum := model.SumUsedQuota(logType, startTimestamp, endTimestamp, modelName, username, tokenName, channel)
+	channels := parseIntArray(c.Query("channel"))
+	quotaNum := model.SumUsedQuota(logType, startTimestamp, endTimestamp, modelName, username, tokenName, channels)
 	//tokenNum := model.SumUsedToken(logType, startTimestamp, endTimestamp, modelName, username, tokenName)
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,

controller/model.go

@@ -2,8 +2,8 @@ package controller
 
 import (
 	"fmt"
+
 	"github.com/gin-gonic/gin"
-	"one-api/relay/channel/openai"
 )
 
 // https://platform.openai.com/docs/api-reference/models/list
@@ -613,14 +613,14 @@ func RetrieveModel(c *gin.Context) {
 	if model, ok := openAIModelsMap[modelId]; ok {
 		c.JSON(200, model)
 	} else {
-		Error := openai.Error{
+		openAIError := OpenAIError{
 			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": Error,
+			"error": openAIError,
 		})
 	}
 }

controller/relay-aiproxy.go

@@ -1,4 +1,4 @@
-package aiproxy
+package controller
 
 import (
 	"bufio"
@@ -8,27 +8,56 @@ import (
 	"io"
 	"net/http"
 	"one-api/common"
-	"one-api/relay/channel/openai"
-	"one-api/relay/constant"
 	"strconv"
 	"strings"
 )
 
 // https://docs.aiproxy.io/dev/library#使用已经定制好的知识库进行对话问答
 
-func ConvertRequest(request openai.GeneralOpenAIRequest) *LibraryRequest {
+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 &LibraryRequest{
+	return &AIProxyLibraryRequest{
 		Model:  request.Model,
 		Stream: request.Stream,
 		Query:  query,
 	}
 }
 
-func aiProxyDocuments2Markdown(documents []LibraryDocument) string {
+func aiProxyDocuments2Markdown(documents []AIProxyLibraryDocument) string {
 	if len(documents) == 0 {
 		return ""
 	}
@@ -39,52 +68,52 @@ func aiProxyDocuments2Markdown(documents []LibraryDocument) string {
 	return content
 }
 
-func responseAIProxyLibrary2OpenAI(response *LibraryResponse) *openai.TextResponse {
+func responseAIProxyLibrary2OpenAI(response *AIProxyLibraryResponse) *OpenAITextResponse {
 	content := response.Answer + aiProxyDocuments2Markdown(response.Documents)
-	choice := openai.TextResponseChoice{
+	choice := OpenAITextResponseChoice{
 		Index: 0,
-		Message: openai.Message{
+		Message: Message{
 			Role:    "assistant",
 			Content: content,
 		},
 		FinishReason: "stop",
 	}
-	fullTextResponse := openai.TextResponse{
+	fullTextResponse := OpenAITextResponse{
 		Id:      common.GetUUID(),
 		Object:  "chat.completion",
 		Created: common.GetTimestamp(),
-		Choices: []openai.TextResponseChoice{choice},
+		Choices: []OpenAITextResponseChoice{choice},
 	}
 	return &fullTextResponse
 }
 
-func documentsAIProxyLibrary(documents []LibraryDocument) *openai.ChatCompletionsStreamResponse {
-	var choice openai.ChatCompletionsStreamResponseChoice
+func documentsAIProxyLibrary(documents []AIProxyLibraryDocument) *ChatCompletionsStreamResponse {
+	var choice ChatCompletionsStreamResponseChoice
 	choice.Delta.Content = aiProxyDocuments2Markdown(documents)
-	choice.FinishReason = &constant.StopFinishReason
-	return &openai.ChatCompletionsStreamResponse{
+	choice.FinishReason = &stopFinishReason
+	return &ChatCompletionsStreamResponse{
 		Id:      common.GetUUID(),
 		Object:  "chat.completion.chunk",
 		Created: common.GetTimestamp(),
 		Model:   "",
-		Choices: []openai.ChatCompletionsStreamResponseChoice{choice},
+		Choices: []ChatCompletionsStreamResponseChoice{choice},
 	}
 }
 
-func streamResponseAIProxyLibrary2OpenAI(response *LibraryStreamResponse) *openai.ChatCompletionsStreamResponse {
-	var choice openai.ChatCompletionsStreamResponseChoice
+func streamResponseAIProxyLibrary2OpenAI(response *AIProxyLibraryStreamResponse) *ChatCompletionsStreamResponse {
+	var choice ChatCompletionsStreamResponseChoice
 	choice.Delta.Content = response.Content
-	return &openai.ChatCompletionsStreamResponse{
+	return &ChatCompletionsStreamResponse{
 		Id:      common.GetUUID(),
 		Object:  "chat.completion.chunk",
 		Created: common.GetTimestamp(),
 		Model:   response.Model,
-		Choices: []openai.ChatCompletionsStreamResponseChoice{choice},
+		Choices: []ChatCompletionsStreamResponseChoice{choice},
 	}
 }
 
-func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode, *openai.Usage) {
-	var usage openai.Usage
+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 {
@@ -114,12 +143,12 @@ func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatus
 		}
 		stopChan <- true
 	}()
-	common.SetEventStreamHeaders(c)
-	var documents []LibraryDocument
+	setEventStreamHeaders(c)
+	var documents []AIProxyLibraryDocument
 	c.Stream(func(w io.Writer) bool {
 		select {
 		case data := <-dataChan:
-			var AIProxyLibraryResponse LibraryStreamResponse
+			var AIProxyLibraryResponse AIProxyLibraryStreamResponse
 			err := json.Unmarshal([]byte(data), &AIProxyLibraryResponse)
 			if err != nil {
 				common.SysError("error unmarshalling stream response: " + err.Error())
@@ -150,28 +179,28 @@ func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatus
 	})
 	err := resp.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
 	}
 	return nil, &usage
 }
 
-func Handler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode, *openai.Usage) {
-	var AIProxyLibraryResponse LibraryResponse
+func aiProxyLibraryHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, *Usage) {
+	var AIProxyLibraryResponse AIProxyLibraryResponse
 	responseBody, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return openai.ErrorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
 	}
 	err = resp.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
 	}
 	err = json.Unmarshal(responseBody, &AIProxyLibraryResponse)
 	if err != nil {
-		return openai.ErrorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
 	}
 	if AIProxyLibraryResponse.ErrCode != 0 {
-		return &openai.ErrorWithStatusCode{
-			Error: openai.Error{
+		return &OpenAIErrorWithStatusCode{
+			OpenAIError: OpenAIError{
 				Message: AIProxyLibraryResponse.Message,
 				Type:    strconv.Itoa(AIProxyLibraryResponse.ErrCode),
 				Code:    AIProxyLibraryResponse.ErrCode,
@@ -182,7 +211,7 @@ func Handler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode,
 	fullTextResponse := responseAIProxyLibrary2OpenAI(&AIProxyLibraryResponse)
 	jsonResponse, err := json.Marshal(fullTextResponse)
 	if err != nil {
-		return openai.ErrorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
 	}
 	c.Writer.Header().Set("Content-Type", "application/json")
 	c.Writer.WriteHeader(resp.StatusCode)

controller/relay-ali.go

@@ -1,4 +1,4 @@
-package ali
+package controller
 
 import (
 	"bufio"
@@ -7,43 +7,112 @@ import (
 	"io"
 	"net/http"
 	"one-api/common"
-	"one-api/relay/channel/openai"
 	"strings"
 )
 
 // https://help.aliyun.com/document_detail/613695.html?spm=a2c4g.2399480.0.0.1adb778fAdzP9w#341800c0f8w0r
 
-const EnableSearchModelSuffix = "-internet"
+type AliMessage struct {
+	Content string `json:"content"`
+	Role    string `json:"role"`
+}
 
-func ConvertRequest(request openai.GeneralOpenAIRequest) *ChatRequest {
-	messages := make([]Message, 0, len(request.Messages))
+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"`
+	IncrementalOutput bool    `json:"incremental_output,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
+}
+
+const AliEnableSearchModelSuffix = "-internet"
+
+func requestOpenAI2Ali(request GeneralOpenAIRequest) *AliChatRequest {
+	messages := make([]AliMessage, 0, len(request.Messages))
 	for i := 0; i < len(request.Messages); i++ {
 		message := request.Messages[i]
-		messages = append(messages, Message{
+		messages = append(messages, AliMessage{
 			Content: message.StringContent(),
 			Role:    strings.ToLower(message.Role),
 		})
 	}
 	enableSearch := false
 	aliModel := request.Model
-	if strings.HasSuffix(aliModel, EnableSearchModelSuffix) {
+	if strings.HasSuffix(aliModel, AliEnableSearchModelSuffix) {
 		enableSearch = true
-		aliModel = strings.TrimSuffix(aliModel, EnableSearchModelSuffix)
+		aliModel = strings.TrimSuffix(aliModel, AliEnableSearchModelSuffix)
 	}
-	return &ChatRequest{
+	return &AliChatRequest{
 		Model: aliModel,
-		Input: Input{
+		Input: AliInput{
 			Messages: messages,
 		},
-		Parameters: Parameters{
+		Parameters: AliParameters{
 			EnableSearch:      enableSearch,
 			IncrementalOutput: request.Stream,
 		},
 	}
 }
 
-func ConvertEmbeddingRequest(request openai.GeneralOpenAIRequest) *EmbeddingRequest {
-	return &EmbeddingRequest{
+func embeddingRequestOpenAI2Ali(request GeneralOpenAIRequest) *AliEmbeddingRequest {
+	return &AliEmbeddingRequest{
 		Model: "text-embedding-v1",
 		Input: struct {
 			Texts []string `json:"texts"`
@@ -53,21 +122,21 @@ func ConvertEmbeddingRequest(request openai.GeneralOpenAIRequest) *EmbeddingRequ
 	}
 }
 
-func EmbeddingHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode, *openai.Usage) {
-	var aliResponse EmbeddingResponse
+func aliEmbeddingHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, *Usage) {
+	var aliResponse AliEmbeddingResponse
 	err := json.NewDecoder(resp.Body).Decode(&aliResponse)
 	if err != nil {
-		return openai.ErrorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
 	}
 
 	err = resp.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
 	}
 
 	if aliResponse.Code != "" {
-		return &openai.ErrorWithStatusCode{
-			Error: openai.Error{
+		return &OpenAIErrorWithStatusCode{
+			OpenAIError: OpenAIError{
 				Message: aliResponse.Message,
 				Type:    aliResponse.Code,
 				Param:   aliResponse.RequestId,
@@ -80,7 +149,7 @@ func EmbeddingHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithSta
 	fullTextResponse := embeddingResponseAli2OpenAI(&aliResponse)
 	jsonResponse, err := json.Marshal(fullTextResponse)
 	if err != nil {
-		return openai.ErrorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
 	}
 	c.Writer.Header().Set("Content-Type", "application/json")
 	c.Writer.WriteHeader(resp.StatusCode)
@@ -88,16 +157,16 @@ func EmbeddingHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithSta
 	return nil, &fullTextResponse.Usage
 }
 
-func embeddingResponseAli2OpenAI(response *EmbeddingResponse) *openai.EmbeddingResponse {
-	openAIEmbeddingResponse := openai.EmbeddingResponse{
+func embeddingResponseAli2OpenAI(response *AliEmbeddingResponse) *OpenAIEmbeddingResponse {
+	openAIEmbeddingResponse := OpenAIEmbeddingResponse{
 		Object: "list",
-		Data:   make([]openai.EmbeddingResponseItem, 0, len(response.Output.Embeddings)),
+		Data:   make([]OpenAIEmbeddingResponseItem, 0, len(response.Output.Embeddings)),
 		Model:  "text-embedding-v1",
-		Usage:  openai.Usage{TotalTokens: response.Usage.TotalTokens},
+		Usage:  Usage{TotalTokens: response.Usage.TotalTokens},
 	}
 
 	for _, item := range response.Output.Embeddings {
-		openAIEmbeddingResponse.Data = append(openAIEmbeddingResponse.Data, openai.EmbeddingResponseItem{
+		openAIEmbeddingResponse.Data = append(openAIEmbeddingResponse.Data, OpenAIEmbeddingResponseItem{
 			Object:    `embedding`,
 			Index:     item.TextIndex,
 			Embedding: item.Embedding,
@@ -106,21 +175,21 @@ func embeddingResponseAli2OpenAI(response *EmbeddingResponse) *openai.EmbeddingR
 	return &openAIEmbeddingResponse
 }
 
-func responseAli2OpenAI(response *ChatResponse) *openai.TextResponse {
-	choice := openai.TextResponseChoice{
+func responseAli2OpenAI(response *AliChatResponse) *OpenAITextResponse {
+	choice := OpenAITextResponseChoice{
 		Index: 0,
-		Message: openai.Message{
+		Message: Message{
 			Role:    "assistant",
 			Content: response.Output.Text,
 		},
 		FinishReason: response.Output.FinishReason,
 	}
-	fullTextResponse := openai.TextResponse{
+	fullTextResponse := OpenAITextResponse{
 		Id:      response.RequestId,
 		Object:  "chat.completion",
 		Created: common.GetTimestamp(),
-		Choices: []openai.TextResponseChoice{choice},
-		Usage: openai.Usage{
+		Choices: []OpenAITextResponseChoice{choice},
+		Usage: Usage{
 			PromptTokens:     response.Usage.InputTokens,
 			CompletionTokens: response.Usage.OutputTokens,
 			TotalTokens:      response.Usage.InputTokens + response.Usage.OutputTokens,
@@ -129,25 +198,25 @@ func responseAli2OpenAI(response *ChatResponse) *openai.TextResponse {
 	return &fullTextResponse
 }
 
-func streamResponseAli2OpenAI(aliResponse *ChatResponse) *openai.ChatCompletionsStreamResponse {
-	var choice openai.ChatCompletionsStreamResponseChoice
+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 := openai.ChatCompletionsStreamResponse{
+	response := ChatCompletionsStreamResponse{
 		Id:      aliResponse.RequestId,
 		Object:  "chat.completion.chunk",
 		Created: common.GetTimestamp(),
 		Model:   "qwen",
-		Choices: []openai.ChatCompletionsStreamResponseChoice{choice},
+		Choices: []ChatCompletionsStreamResponseChoice{choice},
 	}
 	return &response
 }
 
-func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode, *openai.Usage) {
-	var usage openai.Usage
+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 {
@@ -177,12 +246,12 @@ func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatus
 		}
 		stopChan <- true
 	}()
-	common.SetEventStreamHeaders(c)
+	setEventStreamHeaders(c)
 	//lastResponseText := ""
 	c.Stream(func(w io.Writer) bool {
 		select {
 		case data := <-dataChan:
-			var aliResponse ChatResponse
+			var aliResponse AliChatResponse
 			err := json.Unmarshal([]byte(data), &aliResponse)
 			if err != nil {
 				common.SysError("error unmarshalling stream response: " + err.Error())
@@ -210,28 +279,28 @@ func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatus
 	})
 	err := resp.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
 	}
 	return nil, &usage
 }
 
-func Handler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode, *openai.Usage) {
-	var aliResponse ChatResponse
+func aliHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, *Usage) {
+	var aliResponse AliChatResponse
 	responseBody, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return openai.ErrorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
 	}
 	err = resp.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
 	}
 	err = json.Unmarshal(responseBody, &aliResponse)
 	if err != nil {
-		return openai.ErrorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
 	}
 	if aliResponse.Code != "" {
-		return &openai.ErrorWithStatusCode{
-			Error: openai.Error{
+		return &OpenAIErrorWithStatusCode{
+			OpenAIError: OpenAIError{
 				Message: aliResponse.Message,
 				Type:    aliResponse.Code,
 				Param:   aliResponse.RequestId,
@@ -244,7 +313,7 @@ func Handler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode,
 	fullTextResponse.Model = "qwen"
 	jsonResponse, err := json.Marshal(fullTextResponse)
 	if err != nil {
-		return openai.ErrorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
 	}
 	c.Writer.Header().Set("Content-Type", "application/json")
 	c.Writer.WriteHeader(resp.StatusCode)

controller/relay-audio.go

@@ -12,13 +12,10 @@ import (
 	"net/http"
 	"one-api/common"
 	"one-api/model"
-	"one-api/relay/channel/openai"
-	"one-api/relay/constant"
-	"one-api/relay/util"
 	"strings"
 )
 
-func RelayAudioHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode {
+func relayAudioHelper(c *gin.Context, relayMode int) *OpenAIErrorWithStatusCode {
 	audioModel := "whisper-1"
 
 	tokenId := c.GetInt("token_id")
@@ -28,18 +25,18 @@ func RelayAudioHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 	group := c.GetString("group")
 	tokenName := c.GetString("token_name")
 
-	var ttsRequest openai.TextToSpeechRequest
-	if relayMode == constant.RelayModeAudioSpeech {
+	var ttsRequest TextToSpeechRequest
+	if relayMode == RelayModeAudioSpeech {
 		// Read JSON
 		err := common.UnmarshalBodyReusable(c, &ttsRequest)
 		// Check if JSON is valid
 		if err != nil {
-			return openai.ErrorWrapper(err, "invalid_json", http.StatusBadRequest)
+			return errorWrapper(err, "invalid_json", http.StatusBadRequest)
 		}
 		audioModel = ttsRequest.Model
 		// Check if text is too long 4096
 		if len(ttsRequest.Input) > 4096 {
-			return openai.ErrorWrapper(errors.New("input is too long (over 4096 characters)"), "text_too_long", http.StatusBadRequest)
+			return errorWrapper(errors.New("input is too long (over 4096 characters)"), "text_too_long", http.StatusBadRequest)
 		}
 	}
 
@@ -49,7 +46,7 @@ func RelayAudioHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 	var quota int
 	var preConsumedQuota int
 	switch relayMode {
-	case constant.RelayModeAudioSpeech:
+	case RelayModeAudioSpeech:
 		preConsumedQuota = int(float64(len(ttsRequest.Input)) * ratio)
 		quota = preConsumedQuota
 	default:
@@ -57,16 +54,16 @@ func RelayAudioHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 	}
 	userQuota, err := model.CacheGetUserQuota(userId)
 	if err != nil {
-		return openai.ErrorWrapper(err, "get_user_quota_failed", http.StatusInternalServerError)
+		return errorWrapper(err, "get_user_quota_failed", http.StatusInternalServerError)
 	}
 
 	// Check if user quota is enough
 	if userQuota-preConsumedQuota < 0 {
-		return openai.ErrorWrapper(errors.New("user quota is not enough"), "insufficient_user_quota", http.StatusForbidden)
+		return errorWrapper(errors.New("user quota is not enough"), "insufficient_user_quota", http.StatusForbidden)
 	}
 	err = model.CacheDecreaseUserQuota(userId, preConsumedQuota)
 	if err != nil {
-		return openai.ErrorWrapper(err, "decrease_user_quota_failed", http.StatusInternalServerError)
+		return errorWrapper(err, "decrease_user_quota_failed", http.StatusInternalServerError)
 	}
 	if userQuota > 100*preConsumedQuota {
 		// in this case, we do not pre-consume quota
@@ -76,7 +73,7 @@ func RelayAudioHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 	if preConsumedQuota > 0 {
 		err := model.PreConsumeTokenQuota(tokenId, preConsumedQuota)
 		if err != nil {
-			return openai.ErrorWrapper(err, "pre_consume_token_quota_failed", http.StatusForbidden)
+			return errorWrapper(err, "pre_consume_token_quota_failed", http.StatusForbidden)
 		}
 	}
 
@@ -86,7 +83,7 @@ func RelayAudioHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 		modelMap := make(map[string]string)
 		err := json.Unmarshal([]byte(modelMapping), &modelMap)
 		if err != nil {
-			return openai.ErrorWrapper(err, "unmarshal_model_mapping_failed", http.StatusInternalServerError)
+			return errorWrapper(err, "unmarshal_model_mapping_failed", http.StatusInternalServerError)
 		}
 		if modelMap[audioModel] != "" {
 			audioModel = modelMap[audioModel]
@@ -99,27 +96,27 @@ func RelayAudioHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 		baseURL = c.GetString("base_url")
 	}
 
-	fullRequestURL := util.GetFullRequestURL(baseURL, requestURL, channelType)
-	if relayMode == constant.RelayModeAudioTranscription && channelType == common.ChannelTypeAzure {
+	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 := util.GetAPIVersion(c)
+		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 openai.ErrorWrapper(err, "new_request_body_failed", http.StatusInternalServerError)
+		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 openai.ErrorWrapper(err, "new_request_failed", http.StatusInternalServerError)
+		return errorWrapper(err, "new_request_failed", http.StatusInternalServerError)
 	}
 
-	if relayMode == constant.RelayModeAudioTranscription && channelType == common.ChannelTypeAzure {
+	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 ")
@@ -131,34 +128,34 @@ func RelayAudioHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 	req.Header.Set("Content-Type", c.Request.Header.Get("Content-Type"))
 	req.Header.Set("Accept", c.Request.Header.Get("Accept"))
 
-	resp, err := util.HTTPClient.Do(req)
+	resp, err := httpClient.Do(req)
 	if err != nil {
-		return openai.ErrorWrapper(err, "do_request_failed", http.StatusInternalServerError)
+		return errorWrapper(err, "do_request_failed", http.StatusInternalServerError)
 	}
 
 	err = req.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_request_body_failed", http.StatusInternalServerError)
+		return errorWrapper(err, "close_request_body_failed", http.StatusInternalServerError)
 	}
 	err = c.Request.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_request_body_failed", http.StatusInternalServerError)
+		return errorWrapper(err, "close_request_body_failed", http.StatusInternalServerError)
 	}
 
-	if relayMode != constant.RelayModeAudioSpeech {
+	if relayMode != RelayModeAudioSpeech {
 		responseBody, err := io.ReadAll(resp.Body)
 		if err != nil {
-			return openai.ErrorWrapper(err, "read_response_body_failed", http.StatusInternalServerError)
+			return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError)
 		}
 		err = resp.Body.Close()
 		if err != nil {
-			return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError)
+			return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError)
 		}
 
-		var openAIErr openai.SlimTextResponse
+		var openAIErr TextResponse
 		if err = json.Unmarshal(responseBody, &openAIErr); err == nil {
 			if openAIErr.Error.Message != "" {
-				return openai.ErrorWrapper(fmt.Errorf("type %s, code %v, message %s", openAIErr.Error.Type, openAIErr.Error.Code, openAIErr.Error.Message), "request_error", http.StatusInternalServerError)
+				return errorWrapper(fmt.Errorf("type %s, code %v, message %s", openAIErr.Error.Type, openAIErr.Error.Code, openAIErr.Error.Message), "request_error", http.StatusInternalServerError)
 			}
 		}
 
@@ -175,12 +172,12 @@ func RelayAudioHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 		case "vtt":
 			text, err = getTextFromVTT(responseBody)
 		default:
-			return openai.ErrorWrapper(errors.New("unexpected_response_format"), "unexpected_response_format", http.StatusInternalServerError)
+			return errorWrapper(errors.New("unexpected_response_format"), "unexpected_response_format", http.StatusInternalServerError)
 		}
 		if err != nil {
-			return openai.ErrorWrapper(err, "get_text_from_body_err", http.StatusInternalServerError)
+			return errorWrapper(err, "get_text_from_body_err", http.StatusInternalServerError)
 		}
-		quota = openai.CountTokenText(text, audioModel)
+		quota = countTokenText(text, audioModel)
 		resp.Body = io.NopCloser(bytes.NewBuffer(responseBody))
 	}
 	if resp.StatusCode != http.StatusOK {
@@ -196,11 +193,11 @@ func RelayAudioHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 				}()
 			}(c.Request.Context())
 		}
-		return util.RelayErrorHandler(resp)
+		return relayErrorHandler(resp)
 	}
 	quotaDelta := quota - preConsumedQuota
 	defer func(ctx context.Context) {
-		go util.PostConsumeQuota(ctx, tokenId, quotaDelta, quota, userId, channelId, modelRatio, groupRatio, audioModel, tokenName)
+		go postConsumeQuota(ctx, tokenId, quotaDelta, quota, userId, channelId, modelRatio, groupRatio, audioModel, tokenName)
 	}(c.Request.Context())
 
 	for k, v := range resp.Header {
@@ -210,11 +207,11 @@ func RelayAudioHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 
 	_, err = io.Copy(c.Writer, resp.Body)
 	if err != nil {
-		return openai.ErrorWrapper(err, "copy_response_body_failed", http.StatusInternalServerError)
+		return errorWrapper(err, "copy_response_body_failed", http.StatusInternalServerError)
 	}
 	err = resp.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError)
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError)
 	}
 	return nil
 }
@@ -224,7 +221,7 @@ func getTextFromVTT(body []byte) (string, error) {
 }
 
 func getTextFromVerboseJSON(body []byte) (string, error) {
-	var whisperResponse openai.WhisperVerboseJSONResponse
+	var whisperResponse WhisperVerboseJSONResponse
 	if err := json.Unmarshal(body, &whisperResponse); err != nil {
 		return "", fmt.Errorf("unmarshal_response_body_failed err :%w", err)
 	}
@@ -257,7 +254,7 @@ func getTextFromText(body []byte) (string, error) {
 }
 
 func getTextFromJSON(body []byte) (string, error) {
-	var whisperResponse openai.WhisperJSONResponse
+	var whisperResponse WhisperJSONResponse
 	if err := json.Unmarshal(body, &whisperResponse); err != nil {
 		return "", fmt.Errorf("unmarshal_response_body_failed err :%w", err)
 	}

controller/relay-baidu.go

@@ -1,4 +1,4 @@
-package baidu
+package controller
 
 import (
 	"bufio"
@@ -9,9 +9,6 @@ import (
 	"io"
 	"net/http"
 	"one-api/common"
-	"one-api/relay/channel/openai"
-	"one-api/relay/constant"
-	"one-api/relay/util"
 	"strings"
 	"sync"
 	"time"
@@ -40,9 +37,53 @@ type BaiduError struct {
 	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 ConvertRequest(request openai.GeneralOpenAIRequest) *BaiduChatRequest {
+func requestOpenAI2Baidu(request GeneralOpenAIRequest) *BaiduChatRequest {
 	messages := make([]BaiduMessage, 0, len(request.Messages))
 	for _, message := range request.Messages {
 		if message.Role == "system" {
@@ -67,56 +108,56 @@ func ConvertRequest(request openai.GeneralOpenAIRequest) *BaiduChatRequest {
 	}
 }
 
-func responseBaidu2OpenAI(response *ChatResponse) *openai.TextResponse {
-	choice := openai.TextResponseChoice{
+func responseBaidu2OpenAI(response *BaiduChatResponse) *OpenAITextResponse {
+	choice := OpenAITextResponseChoice{
 		Index: 0,
-		Message: openai.Message{
+		Message: Message{
 			Role:    "assistant",
 			Content: response.Result,
 		},
 		FinishReason: "stop",
 	}
-	fullTextResponse := openai.TextResponse{
+	fullTextResponse := OpenAITextResponse{
 		Id:      response.Id,
 		Object:  "chat.completion",
 		Created: response.Created,
-		Choices: []openai.TextResponseChoice{choice},
+		Choices: []OpenAITextResponseChoice{choice},
 		Usage:   response.Usage,
 	}
 	return &fullTextResponse
 }
 
-func streamResponseBaidu2OpenAI(baiduResponse *ChatStreamResponse) *openai.ChatCompletionsStreamResponse {
-	var choice openai.ChatCompletionsStreamResponseChoice
+func streamResponseBaidu2OpenAI(baiduResponse *BaiduChatStreamResponse) *ChatCompletionsStreamResponse {
+	var choice ChatCompletionsStreamResponseChoice
 	choice.Delta.Content = baiduResponse.Result
 	if baiduResponse.IsEnd {
-		choice.FinishReason = &constant.StopFinishReason
+		choice.FinishReason = &stopFinishReason
 	}
-	response := openai.ChatCompletionsStreamResponse{
+	response := ChatCompletionsStreamResponse{
 		Id:      baiduResponse.Id,
 		Object:  "chat.completion.chunk",
 		Created: baiduResponse.Created,
 		Model:   "ernie-bot",
-		Choices: []openai.ChatCompletionsStreamResponseChoice{choice},
+		Choices: []ChatCompletionsStreamResponseChoice{choice},
 	}
 	return &response
 }
 
-func ConvertEmbeddingRequest(request openai.GeneralOpenAIRequest) *EmbeddingRequest {
-	return &EmbeddingRequest{
+func embeddingRequestOpenAI2Baidu(request GeneralOpenAIRequest) *BaiduEmbeddingRequest {
+	return &BaiduEmbeddingRequest{
 		Input: request.ParseInput(),
 	}
 }
 
-func embeddingResponseBaidu2OpenAI(response *EmbeddingResponse) *openai.EmbeddingResponse {
-	openAIEmbeddingResponse := openai.EmbeddingResponse{
+func embeddingResponseBaidu2OpenAI(response *BaiduEmbeddingResponse) *OpenAIEmbeddingResponse {
+	openAIEmbeddingResponse := OpenAIEmbeddingResponse{
 		Object: "list",
-		Data:   make([]openai.EmbeddingResponseItem, 0, len(response.Data)),
+		Data:   make([]OpenAIEmbeddingResponseItem, 0, len(response.Data)),
 		Model:  "baidu-embedding",
 		Usage:  response.Usage,
 	}
 	for _, item := range response.Data {
-		openAIEmbeddingResponse.Data = append(openAIEmbeddingResponse.Data, openai.EmbeddingResponseItem{
+		openAIEmbeddingResponse.Data = append(openAIEmbeddingResponse.Data, OpenAIEmbeddingResponseItem{
 			Object:    item.Object,
 			Index:     item.Index,
 			Embedding: item.Embedding,
@@ -125,8 +166,8 @@ func embeddingResponseBaidu2OpenAI(response *EmbeddingResponse) *openai.Embeddin
 	return &openAIEmbeddingResponse
 }
 
-func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode, *openai.Usage) {
-	var usage openai.Usage
+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 {
@@ -153,11 +194,11 @@ func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatus
 		}
 		stopChan <- true
 	}()
-	common.SetEventStreamHeaders(c)
+	setEventStreamHeaders(c)
 	c.Stream(func(w io.Writer) bool {
 		select {
 		case data := <-dataChan:
-			var baiduResponse ChatStreamResponse
+			var baiduResponse BaiduChatStreamResponse
 			err := json.Unmarshal([]byte(data), &baiduResponse)
 			if err != nil {
 				common.SysError("error unmarshalling stream response: " + err.Error())
@@ -183,28 +224,28 @@ func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatus
 	})
 	err := resp.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
 	}
 	return nil, &usage
 }
 
-func Handler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode, *openai.Usage) {
-	var baiduResponse ChatResponse
+func baiduHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, *Usage) {
+	var baiduResponse BaiduChatResponse
 	responseBody, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return openai.ErrorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
 	}
 	err = resp.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
 	}
 	err = json.Unmarshal(responseBody, &baiduResponse)
 	if err != nil {
-		return openai.ErrorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
 	}
 	if baiduResponse.ErrorMsg != "" {
-		return &openai.ErrorWithStatusCode{
-			Error: openai.Error{
+		return &OpenAIErrorWithStatusCode{
+			OpenAIError: OpenAIError{
 				Message: baiduResponse.ErrorMsg,
 				Type:    "baidu_error",
 				Param:   "",
@@ -217,7 +258,7 @@ func Handler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode,
 	fullTextResponse.Model = "ernie-bot"
 	jsonResponse, err := json.Marshal(fullTextResponse)
 	if err != nil {
-		return openai.ErrorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
 	}
 	c.Writer.Header().Set("Content-Type", "application/json")
 	c.Writer.WriteHeader(resp.StatusCode)
@@ -225,23 +266,23 @@ func Handler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode,
 	return nil, &fullTextResponse.Usage
 }
 
-func EmbeddingHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode, *openai.Usage) {
-	var baiduResponse EmbeddingResponse
+func baiduEmbeddingHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, *Usage) {
+	var baiduResponse BaiduEmbeddingResponse
 	responseBody, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return openai.ErrorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
 	}
 	err = resp.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
 	}
 	err = json.Unmarshal(responseBody, &baiduResponse)
 	if err != nil {
-		return openai.ErrorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
 	}
 	if baiduResponse.ErrorMsg != "" {
-		return &openai.ErrorWithStatusCode{
-			Error: openai.Error{
+		return &OpenAIErrorWithStatusCode{
+			OpenAIError: OpenAIError{
 				Message: baiduResponse.ErrorMsg,
 				Type:    "baidu_error",
 				Param:   "",
@@ -253,7 +294,7 @@ func EmbeddingHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithSta
 	fullTextResponse := embeddingResponseBaidu2OpenAI(&baiduResponse)
 	jsonResponse, err := json.Marshal(fullTextResponse)
 	if err != nil {
-		return openai.ErrorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
 	}
 	c.Writer.Header().Set("Content-Type", "application/json")
 	c.Writer.WriteHeader(resp.StatusCode)
@@ -261,10 +302,10 @@ func EmbeddingHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithSta
 	return nil, &fullTextResponse.Usage
 }
 
-func GetAccessToken(apiKey string) (string, error) {
+func getBaiduAccessToken(apiKey string) (string, error) {
 	if val, ok := baiduTokenStore.Load(apiKey); ok {
-		var accessToken AccessToken
-		if accessToken, ok = val.(AccessToken); 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() {
@@ -279,12 +320,12 @@ func GetAccessToken(apiKey string) (string, error) {
 		return "", err
 	}
 	if accessToken == nil {
-		return "", errors.New("GetAccessToken return a nil token")
+		return "", errors.New("getBaiduAccessToken return a nil token")
 	}
 	return (*accessToken).AccessToken, nil
 }
 
-func getBaiduAccessTokenHelper(apiKey string) (*AccessToken, error) {
+func getBaiduAccessTokenHelper(apiKey string) (*BaiduAccessToken, error) {
 	parts := strings.Split(apiKey, "|")
 	if len(parts) != 2 {
 		return nil, errors.New("invalid baidu apikey")
@@ -296,13 +337,13 @@ func getBaiduAccessTokenHelper(apiKey string) (*AccessToken, error) {
 	}
 	req.Header.Add("Content-Type", "application/json")
 	req.Header.Add("Accept", "application/json")
-	res, err := util.ImpatientHTTPClient.Do(req)
+	res, err := impatientHTTPClient.Do(req)
 	if err != nil {
 		return nil, err
 	}
 	defer res.Body.Close()
 
-	var accessToken AccessToken
+	var accessToken BaiduAccessToken
 	err = json.NewDecoder(res.Body).Decode(&accessToken)
 	if err != nil {
 		return nil, err

controller/relay-claude.go

@@ -1,4 +1,4 @@
-package anthropic
+package controller
 
 import (
 	"bufio"
@@ -8,10 +8,37 @@ import (
 	"io"
 	"net/http"
 	"one-api/common"
-	"one-api/relay/channel/openai"
 	"strings"
 )
 
+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":
@@ -23,8 +50,8 @@ func stopReasonClaude2OpenAI(reason string) string {
 	}
 }
 
-func ConvertRequest(textRequest openai.GeneralOpenAIRequest) *Request {
-	claudeRequest := Request{
+func requestOpenAI2Claude(textRequest GeneralOpenAIRequest) *ClaudeRequest {
+	claudeRequest := ClaudeRequest{
 		Model:             textRequest.Model,
 		Prompt:            "",
 		MaxTokensToSample: textRequest.MaxTokens,
@@ -53,40 +80,40 @@ func ConvertRequest(textRequest openai.GeneralOpenAIRequest) *Request {
 	return &claudeRequest
 }
 
-func streamResponseClaude2OpenAI(claudeResponse *Response) *openai.ChatCompletionsStreamResponse {
-	var choice openai.ChatCompletionsStreamResponseChoice
+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 openai.ChatCompletionsStreamResponse
+	var response ChatCompletionsStreamResponse
 	response.Object = "chat.completion.chunk"
 	response.Model = claudeResponse.Model
-	response.Choices = []openai.ChatCompletionsStreamResponseChoice{choice}
+	response.Choices = []ChatCompletionsStreamResponseChoice{choice}
 	return &response
 }
 
-func responseClaude2OpenAI(claudeResponse *Response) *openai.TextResponse {
-	choice := openai.TextResponseChoice{
+func responseClaude2OpenAI(claudeResponse *ClaudeResponse) *OpenAITextResponse {
+	choice := OpenAITextResponseChoice{
 		Index: 0,
-		Message: openai.Message{
+		Message: Message{
 			Role:    "assistant",
 			Content: strings.TrimPrefix(claudeResponse.Completion, " "),
 			Name:    nil,
 		},
 		FinishReason: stopReasonClaude2OpenAI(claudeResponse.StopReason),
 	}
-	fullTextResponse := openai.TextResponse{
+	fullTextResponse := OpenAITextResponse{
 		Id:      fmt.Sprintf("chatcmpl-%s", common.GetUUID()),
 		Object:  "chat.completion",
 		Created: common.GetTimestamp(),
-		Choices: []openai.TextResponseChoice{choice},
+		Choices: []OpenAITextResponseChoice{choice},
 	}
 	return &fullTextResponse
 }
 
-func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode, string) {
+func claudeStreamHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, string) {
 	responseText := ""
 	responseId := fmt.Sprintf("chatcmpl-%s", common.GetUUID())
 	createdTime := common.GetTimestamp()
@@ -116,13 +143,13 @@ func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatus
 		}
 		stopChan <- true
 	}()
-	common.SetEventStreamHeaders(c)
+	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 Response
+			var claudeResponse ClaudeResponse
 			err := json.Unmarshal([]byte(data), &claudeResponse)
 			if err != nil {
 				common.SysError("error unmarshalling stream response: " + err.Error())
@@ -146,28 +173,28 @@ func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatus
 	})
 	err := resp.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), ""
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), ""
 	}
 	return nil, responseText
 }
 
-func Handler(c *gin.Context, resp *http.Response, promptTokens int, model string) (*openai.ErrorWithStatusCode, *openai.Usage) {
+func claudeHandler(c *gin.Context, resp *http.Response, promptTokens int, model string) (*OpenAIErrorWithStatusCode, *Usage) {
 	responseBody, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return openai.ErrorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
 	}
 	err = resp.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
 	}
-	var claudeResponse Response
+	var claudeResponse ClaudeResponse
 	err = json.Unmarshal(responseBody, &claudeResponse)
 	if err != nil {
-		return openai.ErrorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
 	}
 	if claudeResponse.Error.Type != "" {
-		return &openai.ErrorWithStatusCode{
-			Error: openai.Error{
+		return &OpenAIErrorWithStatusCode{
+			OpenAIError: OpenAIError{
 				Message: claudeResponse.Error.Message,
 				Type:    claudeResponse.Error.Type,
 				Param:   "",
@@ -178,8 +205,8 @@ func Handler(c *gin.Context, resp *http.Response, promptTokens int, model string
 	}
 	fullTextResponse := responseClaude2OpenAI(&claudeResponse)
 	fullTextResponse.Model = model
-	completionTokens := openai.CountTokenText(claudeResponse.Completion, model)
-	usage := openai.Usage{
+	completionTokens := countTokenText(claudeResponse.Completion, model)
+	usage := Usage{
 		PromptTokens:     promptTokens,
 		CompletionTokens: completionTokens,
 		TotalTokens:      promptTokens + completionTokens,
@@ -187,7 +214,7 @@ func Handler(c *gin.Context, resp *http.Response, promptTokens int, model string
 	fullTextResponse.Usage = usage
 	jsonResponse, err := json.Marshal(fullTextResponse)
 	if err != nil {
-		return openai.ErrorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
 	}
 	c.Writer.Header().Set("Content-Type", "application/json")
 	c.Writer.WriteHeader(resp.StatusCode)

controller/relay-gemini.go

@@ -1,4 +1,4 @@
-package google
+package controller
 
 import (
 	"bufio"
@@ -8,8 +8,6 @@ import (
 	"net/http"
 	"one-api/common"
 	"one-api/common/image"
-	"one-api/relay/channel/openai"
-	"one-api/relay/constant"
 	"strings"
 
 	"github.com/gin-gonic/gin"
@@ -21,8 +19,48 @@ 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 ConvertGeminiRequest(textRequest openai.GeneralOpenAIRequest) *GeminiChatRequest {
+func requestOpenAI2Gemini(textRequest GeneralOpenAIRequest) *GeminiChatRequest {
 	geminiRequest := GeminiChatRequest{
 		Contents: make([]GeminiChatContent, 0, len(textRequest.Messages)),
 		SafetySettings: []GeminiChatSafetySettings{
@@ -70,11 +108,11 @@ func ConvertGeminiRequest(textRequest openai.GeneralOpenAIRequest) *GeminiChatRe
 		var parts []GeminiPart
 		imageNum := 0
 		for _, part := range openaiContent {
-			if part.Type == openai.ContentTypeText {
+			if part.Type == ContentTypeText {
 				parts = append(parts, GeminiPart{
 					Text: part.Text,
 				})
-			} else if part.Type == openai.ContentTypeImageURL {
+			} else if part.Type == ContentTypeImageURL {
 				imageNum += 1
 				if imageNum > GeminiVisionMaxImageNum {
 					continue
@@ -149,21 +187,21 @@ type GeminiChatPromptFeedback struct {
 	SafetyRatings []GeminiChatSafetyRating `json:"safetyRatings"`
 }
 
-func responseGeminiChat2OpenAI(response *GeminiChatResponse) *openai.TextResponse {
-	fullTextResponse := openai.TextResponse{
+func responseGeminiChat2OpenAI(response *GeminiChatResponse) *OpenAITextResponse {
+	fullTextResponse := OpenAITextResponse{
 		Id:      fmt.Sprintf("chatcmpl-%s", common.GetUUID()),
 		Object:  "chat.completion",
 		Created: common.GetTimestamp(),
-		Choices: make([]openai.TextResponseChoice, 0, len(response.Candidates)),
+		Choices: make([]OpenAITextResponseChoice, 0, len(response.Candidates)),
 	}
 	for i, candidate := range response.Candidates {
-		choice := openai.TextResponseChoice{
+		choice := OpenAITextResponseChoice{
 			Index: i,
-			Message: openai.Message{
+			Message: Message{
 				Role:    "assistant",
 				Content: "",
 			},
-			FinishReason: constant.StopFinishReason,
+			FinishReason: stopFinishReason,
 		}
 		if len(candidate.Content.Parts) > 0 {
 			choice.Message.Content = candidate.Content.Parts[0].Text
@@ -173,18 +211,18 @@ func responseGeminiChat2OpenAI(response *GeminiChatResponse) *openai.TextRespons
 	return &fullTextResponse
 }
 
-func streamResponseGeminiChat2OpenAI(geminiResponse *GeminiChatResponse) *openai.ChatCompletionsStreamResponse {
-	var choice openai.ChatCompletionsStreamResponseChoice
+func streamResponseGeminiChat2OpenAI(geminiResponse *GeminiChatResponse) *ChatCompletionsStreamResponse {
+	var choice ChatCompletionsStreamResponseChoice
 	choice.Delta.Content = geminiResponse.GetResponseText()
-	choice.FinishReason = &constant.StopFinishReason
-	var response openai.ChatCompletionsStreamResponse
+	choice.FinishReason = &stopFinishReason
+	var response ChatCompletionsStreamResponse
 	response.Object = "chat.completion.chunk"
 	response.Model = "gemini"
-	response.Choices = []openai.ChatCompletionsStreamResponseChoice{choice}
+	response.Choices = []ChatCompletionsStreamResponseChoice{choice}
 	return &response
 }
 
-func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode, string) {
+func geminiChatStreamHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, string) {
 	responseText := ""
 	dataChan := make(chan string)
 	stopChan := make(chan bool)
@@ -214,7 +252,7 @@ func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatus
 		}
 		stopChan <- true
 	}()
-	common.SetEventStreamHeaders(c)
+	setEventStreamHeaders(c)
 	c.Stream(func(w io.Writer) bool {
 		select {
 		case data := <-dataChan:
@@ -226,14 +264,14 @@ func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatus
 			var dummy dummyStruct
 			err := json.Unmarshal([]byte(data), &dummy)
 			responseText += dummy.Content
-			var choice openai.ChatCompletionsStreamResponseChoice
+			var choice ChatCompletionsStreamResponseChoice
 			choice.Delta.Content = dummy.Content
-			response := openai.ChatCompletionsStreamResponse{
+			response := ChatCompletionsStreamResponse{
 				Id:      fmt.Sprintf("chatcmpl-%s", common.GetUUID()),
 				Object:  "chat.completion.chunk",
 				Created: common.GetTimestamp(),
 				Model:   "gemini-pro",
-				Choices: []openai.ChatCompletionsStreamResponseChoice{choice},
+				Choices: []ChatCompletionsStreamResponseChoice{choice},
 			}
 			jsonResponse, err := json.Marshal(response)
 			if err != nil {
@@ -249,28 +287,28 @@ func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatus
 	})
 	err := resp.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), ""
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), ""
 	}
 	return nil, responseText
 }
 
-func GeminiHandler(c *gin.Context, resp *http.Response, promptTokens int, model string) (*openai.ErrorWithStatusCode, *openai.Usage) {
+func geminiChatHandler(c *gin.Context, resp *http.Response, promptTokens int, model string) (*OpenAIErrorWithStatusCode, *Usage) {
 	responseBody, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return openai.ErrorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
 	}
 	err = resp.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
 	}
 	var geminiResponse GeminiChatResponse
 	err = json.Unmarshal(responseBody, &geminiResponse)
 	if err != nil {
-		return openai.ErrorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
 	}
 	if len(geminiResponse.Candidates) == 0 {
-		return &openai.ErrorWithStatusCode{
-			Error: openai.Error{
+		return &OpenAIErrorWithStatusCode{
+			OpenAIError: OpenAIError{
 				Message: "No candidates returned",
 				Type:    "server_error",
 				Param:   "",
@@ -281,8 +319,8 @@ func GeminiHandler(c *gin.Context, resp *http.Response, promptTokens int, model
 	}
 	fullTextResponse := responseGeminiChat2OpenAI(&geminiResponse)
 	fullTextResponse.Model = model
-	completionTokens := openai.CountTokenText(geminiResponse.GetResponseText(), model)
-	usage := openai.Usage{
+	completionTokens := countTokenText(geminiResponse.GetResponseText(), model)
+	usage := Usage{
 		PromptTokens:     promptTokens,
 		CompletionTokens: completionTokens,
 		TotalTokens:      promptTokens + completionTokens,
@@ -290,7 +328,7 @@ func GeminiHandler(c *gin.Context, resp *http.Response, promptTokens int, model
 	fullTextResponse.Usage = usage
 	jsonResponse, err := json.Marshal(fullTextResponse)
 	if err != nil {
-		return openai.ErrorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
 	}
 	c.Writer.Header().Set("Content-Type", "application/json")
 	c.Writer.WriteHeader(resp.StatusCode)

controller/relay-image.go

@@ -10,8 +10,6 @@ import (
 	"net/http"
 	"one-api/common"
 	"one-api/model"
-	"one-api/relay/channel/openai"
-	"one-api/relay/util"
 	"strings"
 
 	"github.com/gin-gonic/gin"
@@ -27,7 +25,7 @@ func isWithinRange(element string, value int) bool {
 	return value >= min && value <= max
 }
 
-func RelayImageHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode {
+func relayImageHelper(c *gin.Context, relayMode int) *OpenAIErrorWithStatusCode {
 	imageModel := "dall-e-2"
 	imageSize := "1024x1024"
 
@@ -37,10 +35,10 @@ func RelayImageHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 	userId := c.GetInt("id")
 	group := c.GetString("group")
 
-	var imageRequest openai.ImageRequest
+	var imageRequest ImageRequest
 	err := common.UnmarshalBodyReusable(c, &imageRequest)
 	if err != nil {
-		return openai.ErrorWrapper(err, "bind_request_body_failed", http.StatusBadRequest)
+		return errorWrapper(err, "bind_request_body_failed", http.StatusBadRequest)
 	}
 
 	if imageRequest.N == 0 {
@@ -69,24 +67,24 @@ func RelayImageHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 			}
 		}
 	} else {
-		return openai.ErrorWrapper(errors.New("size not supported for this image model"), "size_not_supported", http.StatusBadRequest)
+		return errorWrapper(errors.New("size not supported for this image model"), "size_not_supported", http.StatusBadRequest)
 	}
 
 	// Prompt validation
 	if imageRequest.Prompt == "" {
-		return openai.ErrorWrapper(errors.New("prompt is required"), "prompt_missing", http.StatusBadRequest)
+		return errorWrapper(errors.New("prompt is required"), "prompt_missing", http.StatusBadRequest)
 	}
 
 	// Check prompt length
 	if len(imageRequest.Prompt) > common.DalleImagePromptLengthLimitations[imageModel] {
-		return openai.ErrorWrapper(errors.New("prompt is too long"), "prompt_too_long", http.StatusBadRequest)
+		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 openai.ErrorWrapper(errors.New("invalid value of n"), "n_not_within_range", http.StatusBadRequest)
+			return errorWrapper(errors.New("invalid value of n"), "n_not_within_range", http.StatusBadRequest)
 		}
 	}
 
@@ -97,7 +95,7 @@ func RelayImageHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 		modelMap := make(map[string]string)
 		err := json.Unmarshal([]byte(modelMapping), &modelMap)
 		if err != nil {
-			return openai.ErrorWrapper(err, "unmarshal_model_mapping_failed", http.StatusInternalServerError)
+			return errorWrapper(err, "unmarshal_model_mapping_failed", http.StatusInternalServerError)
 		}
 		if modelMap[imageModel] != "" {
 			imageModel = modelMap[imageModel]
@@ -109,10 +107,10 @@ func RelayImageHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 	if c.GetString("base_url") != "" {
 		baseURL = c.GetString("base_url")
 	}
-	fullRequestURL := util.GetFullRequestURL(baseURL, requestURL, channelType)
+	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 := util.GetAPIVersion(c)
+		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)
 	}
@@ -121,7 +119,7 @@ func RelayImageHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 	if isModelMapped || channelType == common.ChannelTypeAzure { // make Azure channel request body
 		jsonStr, err := json.Marshal(imageRequest)
 		if err != nil {
-			return openai.ErrorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
+			return errorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
 		}
 		requestBody = bytes.NewBuffer(jsonStr)
 	} else {
@@ -136,12 +134,12 @@ func RelayImageHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 	quota := int(ratio*imageCostRatio*1000) * imageRequest.N
 
 	if userQuota-quota < 0 {
-		return openai.ErrorWrapper(errors.New("user quota is not enough"), "insufficient_user_quota", http.StatusForbidden)
+		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 openai.ErrorWrapper(err, "new_request_failed", http.StatusInternalServerError)
+		return errorWrapper(err, "new_request_failed", http.StatusInternalServerError)
 	}
 	token := c.Request.Header.Get("Authorization")
 	if channelType == common.ChannelTypeAzure { // Azure authentication
@@ -154,20 +152,20 @@ func RelayImageHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 	req.Header.Set("Content-Type", c.Request.Header.Get("Content-Type"))
 	req.Header.Set("Accept", c.Request.Header.Get("Accept"))
 
-	resp, err := util.HTTPClient.Do(req)
+	resp, err := httpClient.Do(req)
 	if err != nil {
-		return openai.ErrorWrapper(err, "do_request_failed", http.StatusInternalServerError)
+		return errorWrapper(err, "do_request_failed", http.StatusInternalServerError)
 	}
 
 	err = req.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_request_body_failed", http.StatusInternalServerError)
+		return errorWrapper(err, "close_request_body_failed", http.StatusInternalServerError)
 	}
 	err = c.Request.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_request_body_failed", http.StatusInternalServerError)
+		return errorWrapper(err, "close_request_body_failed", http.StatusInternalServerError)
 	}
-	var textResponse openai.ImageResponse
+	var textResponse ImageResponse
 
 	defer func(ctx context.Context) {
 		if resp.StatusCode != http.StatusOK {
@@ -194,15 +192,15 @@ func RelayImageHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 	responseBody, err := io.ReadAll(resp.Body)
 
 	if err != nil {
-		return openai.ErrorWrapper(err, "read_response_body_failed", http.StatusInternalServerError)
+		return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError)
 	}
 	err = resp.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError)
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError)
 	}
 	err = json.Unmarshal(responseBody, &textResponse)
 	if err != nil {
-		return openai.ErrorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError)
+		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError)
 	}
 
 	resp.Body = io.NopCloser(bytes.NewBuffer(responseBody))
@@ -214,11 +212,11 @@ func RelayImageHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 
 	_, err = io.Copy(c.Writer, resp.Body)
 	if err != nil {
-		return openai.ErrorWrapper(err, "copy_response_body_failed", http.StatusInternalServerError)
+		return errorWrapper(err, "copy_response_body_failed", http.StatusInternalServerError)
 	}
 	err = resp.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError)
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError)
 	}
 	return nil
 }

controller/relay-openai.go

@@ -1,4 +1,4 @@
-package openai
+package controller
 
 import (
 	"bufio"
@@ -8,11 +8,10 @@ import (
 	"io"
 	"net/http"
 	"one-api/common"
-	"one-api/relay/constant"
 	"strings"
 )
 
-func StreamHandler(c *gin.Context, resp *http.Response, relayMode int) (*ErrorWithStatusCode, string) {
+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) {
@@ -42,7 +41,7 @@ func StreamHandler(c *gin.Context, resp *http.Response, relayMode int) (*ErrorWi
 			data = data[6:]
 			if !strings.HasPrefix(data, "[DONE]") {
 				switch relayMode {
-				case constant.RelayModeChatCompletions:
+				case RelayModeChatCompletions:
 					var streamResponse ChatCompletionsStreamResponse
 					err := json.Unmarshal([]byte(data), &streamResponse)
 					if err != nil {
@@ -52,7 +51,7 @@ func StreamHandler(c *gin.Context, resp *http.Response, relayMode int) (*ErrorWi
 					for _, choice := range streamResponse.Choices {
 						responseText += choice.Delta.Content
 					}
-				case constant.RelayModeCompletions:
+				case RelayModeCompletions:
 					var streamResponse CompletionsStreamResponse
 					err := json.Unmarshal([]byte(data), &streamResponse)
 					if err != nil {
@@ -67,7 +66,7 @@ func StreamHandler(c *gin.Context, resp *http.Response, relayMode int) (*ErrorWi
 		}
 		stopChan <- true
 	}()
-	common.SetEventStreamHeaders(c)
+	setEventStreamHeaders(c)
 	c.Stream(func(w io.Writer) bool {
 		select {
 		case data := <-dataChan:
@@ -84,29 +83,29 @@ func StreamHandler(c *gin.Context, resp *http.Response, relayMode int) (*ErrorWi
 	})
 	err := resp.Body.Close()
 	if err != nil {
-		return ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), ""
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), ""
 	}
 	return nil, responseText
 }
 
-func Handler(c *gin.Context, resp *http.Response, promptTokens int, model string) (*ErrorWithStatusCode, *Usage) {
-	var textResponse SlimTextResponse
+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
+		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
+		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
+		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
 	}
 	if textResponse.Error.Type != "" {
-		return &ErrorWithStatusCode{
-			Error:      textResponse.Error,
-			StatusCode: resp.StatusCode,
+		return &OpenAIErrorWithStatusCode{
+			OpenAIError: textResponse.Error,
+			StatusCode:  resp.StatusCode,
 		}, nil
 	}
 	// Reset response body
@@ -114,7 +113,7 @@ func Handler(c *gin.Context, resp *http.Response, promptTokens int, model string
 
 	// 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.
+	// 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])
@@ -122,17 +121,17 @@ func Handler(c *gin.Context, resp *http.Response, promptTokens int, model string
 	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
+		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
+		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)
+			completionTokens += countTokenText(choice.Message.StringContent(), model)
 		}
 		textResponse.Usage = Usage{
 			PromptTokens:     promptTokens,

controller/relay-palm.go

@@ -1,4 +1,4 @@
-package google
+package controller
 
 import (
 	"encoding/json"
@@ -7,14 +7,47 @@ import (
 	"io"
 	"net/http"
 	"one-api/common"
-	"one-api/relay/channel/openai"
-	"one-api/relay/constant"
 )
 
 // https://developers.generativeai.google/api/rest/generativelanguage/models/generateMessage#request-body
 // https://developers.generativeai.google/api/rest/generativelanguage/models/generateMessage#response-body
 
-func ConvertPaLMRequest(textRequest openai.GeneralOpenAIRequest) *PaLMChatRequest {
+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)),
@@ -38,14 +71,14 @@ func ConvertPaLMRequest(textRequest openai.GeneralOpenAIRequest) *PaLMChatReques
 	return &palmRequest
 }
 
-func responsePaLM2OpenAI(response *PaLMChatResponse) *openai.TextResponse {
-	fullTextResponse := openai.TextResponse{
-		Choices: make([]openai.TextResponseChoice, 0, len(response.Candidates)),
+func responsePaLM2OpenAI(response *PaLMChatResponse) *OpenAITextResponse {
+	fullTextResponse := OpenAITextResponse{
+		Choices: make([]OpenAITextResponseChoice, 0, len(response.Candidates)),
 	}
 	for i, candidate := range response.Candidates {
-		choice := openai.TextResponseChoice{
+		choice := OpenAITextResponseChoice{
 			Index: i,
-			Message: openai.Message{
+			Message: Message{
 				Role:    "assistant",
 				Content: candidate.Content,
 			},
@@ -56,20 +89,20 @@ func responsePaLM2OpenAI(response *PaLMChatResponse) *openai.TextResponse {
 	return &fullTextResponse
 }
 
-func streamResponsePaLM2OpenAI(palmResponse *PaLMChatResponse) *openai.ChatCompletionsStreamResponse {
-	var choice openai.ChatCompletionsStreamResponseChoice
+func streamResponsePaLM2OpenAI(palmResponse *PaLMChatResponse) *ChatCompletionsStreamResponse {
+	var choice ChatCompletionsStreamResponseChoice
 	if len(palmResponse.Candidates) > 0 {
 		choice.Delta.Content = palmResponse.Candidates[0].Content
 	}
-	choice.FinishReason = &constant.StopFinishReason
-	var response openai.ChatCompletionsStreamResponse
+	choice.FinishReason = &stopFinishReason
+	var response ChatCompletionsStreamResponse
 	response.Object = "chat.completion.chunk"
 	response.Model = "palm2"
-	response.Choices = []openai.ChatCompletionsStreamResponseChoice{choice}
+	response.Choices = []ChatCompletionsStreamResponseChoice{choice}
 	return &response
 }
 
-func PaLMStreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode, string) {
+func palmStreamHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, string) {
 	responseText := ""
 	responseId := fmt.Sprintf("chatcmpl-%s", common.GetUUID())
 	createdTime := common.GetTimestamp()
@@ -110,7 +143,7 @@ func PaLMStreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithSt
 		dataChan <- string(jsonResponse)
 		stopChan <- true
 	}()
-	common.SetEventStreamHeaders(c)
+	setEventStreamHeaders(c)
 	c.Stream(func(w io.Writer) bool {
 		select {
 		case data := <-dataChan:
@@ -123,28 +156,28 @@ func PaLMStreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithSt
 	})
 	err := resp.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), ""
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), ""
 	}
 	return nil, responseText
 }
 
-func PaLMHandler(c *gin.Context, resp *http.Response, promptTokens int, model string) (*openai.ErrorWithStatusCode, *openai.Usage) {
+func palmHandler(c *gin.Context, resp *http.Response, promptTokens int, model string) (*OpenAIErrorWithStatusCode, *Usage) {
 	responseBody, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return openai.ErrorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
 	}
 	err = resp.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
 	}
 	var palmResponse PaLMChatResponse
 	err = json.Unmarshal(responseBody, &palmResponse)
 	if err != nil {
-		return openai.ErrorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
 	}
 	if palmResponse.Error.Code != 0 || len(palmResponse.Candidates) == 0 {
-		return &openai.ErrorWithStatusCode{
-			Error: openai.Error{
+		return &OpenAIErrorWithStatusCode{
+			OpenAIError: OpenAIError{
 				Message: palmResponse.Error.Message,
 				Type:    palmResponse.Error.Status,
 				Param:   "",
@@ -155,8 +188,8 @@ func PaLMHandler(c *gin.Context, resp *http.Response, promptTokens int, model st
 	}
 	fullTextResponse := responsePaLM2OpenAI(&palmResponse)
 	fullTextResponse.Model = model
-	completionTokens := openai.CountTokenText(palmResponse.Candidates[0].Content, model)
-	usage := openai.Usage{
+	completionTokens := countTokenText(palmResponse.Candidates[0].Content, model)
+	usage := Usage{
 		PromptTokens:     promptTokens,
 		CompletionTokens: completionTokens,
 		TotalTokens:      promptTokens + completionTokens,
@@ -164,7 +197,7 @@ func PaLMHandler(c *gin.Context, resp *http.Response, promptTokens int, model st
 	fullTextResponse.Usage = usage
 	jsonResponse, err := json.Marshal(fullTextResponse)
 	if err != nil {
-		return openai.ErrorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
 	}
 	c.Writer.Header().Set("Content-Type", "application/json")
 	c.Writer.WriteHeader(resp.StatusCode)

controller/relay-tencent.go

@@ -1,4 +1,4 @@
-package tencent
+package controller
 
 import (
 	"bufio"
@@ -12,8 +12,6 @@ import (
 	"io"
 	"net/http"
 	"one-api/common"
-	"one-api/relay/channel/openai"
-	"one-api/relay/constant"
 	"sort"
 	"strconv"
 	"strings"
@@ -21,22 +19,80 @@ import (
 
 // https://cloud.tencent.com/document/product/1729/97732
 
-func ConvertRequest(request openai.GeneralOpenAIRequest) *ChatRequest {
-	messages := make([]Message, 0, len(request.Messages))
+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, Message{
+			messages = append(messages, TencentMessage{
 				Role:    "user",
 				Content: message.StringContent(),
 			})
-			messages = append(messages, Message{
+			messages = append(messages, TencentMessage{
 				Role:    "assistant",
 				Content: "Okay",
 			})
 			continue
 		}
-		messages = append(messages, Message{
+		messages = append(messages, TencentMessage{
 			Content: message.StringContent(),
 			Role:    message.Role,
 		})
@@ -45,7 +101,7 @@ func ConvertRequest(request openai.GeneralOpenAIRequest) *ChatRequest {
 	if request.Stream {
 		stream = 1
 	}
-	return &ChatRequest{
+	return &TencentChatRequest{
 		Timestamp:   common.GetTimestamp(),
 		Expired:     common.GetTimestamp() + 24*60*60,
 		QueryID:     common.GetUUID(),
@@ -56,16 +112,16 @@ func ConvertRequest(request openai.GeneralOpenAIRequest) *ChatRequest {
 	}
 }
 
-func responseTencent2OpenAI(response *ChatResponse) *openai.TextResponse {
-	fullTextResponse := openai.TextResponse{
+func responseTencent2OpenAI(response *TencentChatResponse) *OpenAITextResponse {
+	fullTextResponse := OpenAITextResponse{
 		Object:  "chat.completion",
 		Created: common.GetTimestamp(),
 		Usage:   response.Usage,
 	}
 	if len(response.Choices) > 0 {
-		choice := openai.TextResponseChoice{
+		choice := OpenAITextResponseChoice{
 			Index: 0,
-			Message: openai.Message{
+			Message: Message{
 				Role:    "assistant",
 				Content: response.Choices[0].Messages.Content,
 			},
@@ -76,24 +132,24 @@ func responseTencent2OpenAI(response *ChatResponse) *openai.TextResponse {
 	return &fullTextResponse
 }
 
-func streamResponseTencent2OpenAI(TencentResponse *ChatResponse) *openai.ChatCompletionsStreamResponse {
-	response := openai.ChatCompletionsStreamResponse{
+func streamResponseTencent2OpenAI(TencentResponse *TencentChatResponse) *ChatCompletionsStreamResponse {
+	response := ChatCompletionsStreamResponse{
 		Object:  "chat.completion.chunk",
 		Created: common.GetTimestamp(),
 		Model:   "tencent-hunyuan",
 	}
 	if len(TencentResponse.Choices) > 0 {
-		var choice openai.ChatCompletionsStreamResponseChoice
+		var choice ChatCompletionsStreamResponseChoice
 		choice.Delta.Content = TencentResponse.Choices[0].Delta.Content
 		if TencentResponse.Choices[0].FinishReason == "stop" {
-			choice.FinishReason = &constant.StopFinishReason
+			choice.FinishReason = &stopFinishReason
 		}
 		response.Choices = append(response.Choices, choice)
 	}
 	return &response
 }
 
-func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode, string) {
+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) {
@@ -124,11 +180,11 @@ func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatus
 		}
 		stopChan <- true
 	}()
-	common.SetEventStreamHeaders(c)
+	setEventStreamHeaders(c)
 	c.Stream(func(w io.Writer) bool {
 		select {
 		case data := <-dataChan:
-			var TencentResponse ChatResponse
+			var TencentResponse TencentChatResponse
 			err := json.Unmarshal([]byte(data), &TencentResponse)
 			if err != nil {
 				common.SysError("error unmarshalling stream response: " + err.Error())
@@ -152,28 +208,28 @@ func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatus
 	})
 	err := resp.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), ""
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), ""
 	}
 	return nil, responseText
 }
 
-func Handler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode, *openai.Usage) {
-	var TencentResponse ChatResponse
+func tencentHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, *Usage) {
+	var TencentResponse TencentChatResponse
 	responseBody, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return openai.ErrorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
 	}
 	err = resp.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
 	}
 	err = json.Unmarshal(responseBody, &TencentResponse)
 	if err != nil {
-		return openai.ErrorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
 	}
 	if TencentResponse.Error.Code != 0 {
-		return &openai.ErrorWithStatusCode{
-			Error: openai.Error{
+		return &OpenAIErrorWithStatusCode{
+			OpenAIError: OpenAIError{
 				Message: TencentResponse.Error.Message,
 				Code:    TencentResponse.Error.Code,
 			},
@@ -184,7 +240,7 @@ func Handler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode,
 	fullTextResponse.Model = "hunyuan"
 	jsonResponse, err := json.Marshal(fullTextResponse)
 	if err != nil {
-		return openai.ErrorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
 	}
 	c.Writer.Header().Set("Content-Type", "application/json")
 	c.Writer.WriteHeader(resp.StatusCode)
@@ -192,7 +248,7 @@ func Handler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode,
 	return nil, &fullTextResponse.Usage
 }
 
-func ParseConfig(config string) (appId int64, secretId string, secretKey string, err error) {
+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")
@@ -204,7 +260,7 @@ func ParseConfig(config string) (appId int64, secretId string, secretKey string,
 	return
 }
 
-func GetSign(req ChatRequest, secretKey string) string {
+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)

controller/relay-text.go

@@ -6,24 +6,15 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/gin-gonic/gin"
 	"io"
 	"math"
 	"net/http"
 	"one-api/common"
 	"one-api/model"
-	"one-api/relay/channel/aiproxy"
-	"one-api/relay/channel/ali"
-	"one-api/relay/channel/anthropic"
-	"one-api/relay/channel/baidu"
-	"one-api/relay/channel/google"
-	"one-api/relay/channel/openai"
-	"one-api/relay/channel/tencent"
-	"one-api/relay/channel/xunfei"
-	"one-api/relay/channel/zhipu"
-	"one-api/relay/constant"
-	"one-api/relay/util"
 	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
 )
 
 const (
@@ -39,47 +30,64 @@ const (
 	APITypeGemini
 )
 
-func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode {
+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 openai.GeneralOpenAIRequest
+	var textRequest GeneralOpenAIRequest
 	err := common.UnmarshalBodyReusable(c, &textRequest)
 	if err != nil {
-		return openai.ErrorWrapper(err, "bind_request_body_failed", http.StatusBadRequest)
+		return errorWrapper(err, "bind_request_body_failed", http.StatusBadRequest)
 	}
 	if textRequest.MaxTokens < 0 || textRequest.MaxTokens > math.MaxInt32/2 {
-		return openai.ErrorWrapper(errors.New("max_tokens is invalid"), "invalid_max_tokens", http.StatusBadRequest)
+		return errorWrapper(errors.New("max_tokens is invalid"), "invalid_max_tokens", http.StatusBadRequest)
 	}
-	if relayMode == constant.RelayModeModerations && textRequest.Model == "" {
+	if relayMode == RelayModeModerations && textRequest.Model == "" {
 		textRequest.Model = "text-moderation-latest"
 	}
-	if relayMode == constant.RelayModeEmbeddings && textRequest.Model == "" {
+	if relayMode == RelayModeEmbeddings && textRequest.Model == "" {
 		textRequest.Model = c.Param("model")
 	}
 	// request validation
 	if textRequest.Model == "" {
-		return openai.ErrorWrapper(errors.New("model is required"), "required_field_missing", http.StatusBadRequest)
+		return errorWrapper(errors.New("model is required"), "required_field_missing", http.StatusBadRequest)
 	}
 	switch relayMode {
-	case constant.RelayModeCompletions:
+	case RelayModeCompletions:
 		if textRequest.Prompt == "" {
-			return openai.ErrorWrapper(errors.New("field prompt is required"), "required_field_missing", http.StatusBadRequest)
+			return errorWrapper(errors.New("field prompt is required"), "required_field_missing", http.StatusBadRequest)
 		}
-	case constant.RelayModeChatCompletions:
+	case RelayModeChatCompletions:
 		if textRequest.Messages == nil || len(textRequest.Messages) == 0 {
-			return openai.ErrorWrapper(errors.New("field messages is required"), "required_field_missing", http.StatusBadRequest)
+			return errorWrapper(errors.New("field messages is required"), "required_field_missing", http.StatusBadRequest)
 		}
-	case constant.RelayModeEmbeddings:
-	case constant.RelayModeModerations:
+	case RelayModeEmbeddings:
+	case RelayModeModerations:
 		if textRequest.Input == "" {
-			return openai.ErrorWrapper(errors.New("field input is required"), "required_field_missing", http.StatusBadRequest)
+			return errorWrapper(errors.New("field input is required"), "required_field_missing", http.StatusBadRequest)
 		}
-	case constant.RelayModeEdits:
+	case RelayModeEdits:
 		if textRequest.Instruction == "" {
-			return openai.ErrorWrapper(errors.New("field instruction is required"), "required_field_missing", http.StatusBadRequest)
+			return errorWrapper(errors.New("field instruction is required"), "required_field_missing", http.StatusBadRequest)
 		}
 	}
 	// map model name
@@ -89,7 +97,7 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 		modelMap := make(map[string]string)
 		err := json.Unmarshal([]byte(modelMapping), &modelMap)
 		if err != nil {
-			return openai.ErrorWrapper(err, "unmarshal_model_mapping_failed", http.StatusInternalServerError)
+			return errorWrapper(err, "unmarshal_model_mapping_failed", http.StatusInternalServerError)
 		}
 		if modelMap[textRequest.Model] != "" {
 			textRequest.Model = modelMap[textRequest.Model]
@@ -122,12 +130,12 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 	if c.GetString("base_url") != "" {
 		baseURL = c.GetString("base_url")
 	}
-	fullRequestURL := util.GetFullRequestURL(baseURL, requestURL, channelType)
+	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 := util.GetAPIVersion(c)
+			apiVersion := GetAPIVersion(c)
 			requestURL := strings.Split(requestURL, "?")[0]
 			requestURL = fmt.Sprintf("%s?api-version=%s", requestURL, apiVersion)
 			baseURL = c.GetString("base_url")
@@ -140,7 +148,7 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 			model_ = strings.TrimSuffix(model_, "-0613")
 
 			requestURL = fmt.Sprintf("/openai/deployments/%s/%s", model_, task)
-			fullRequestURL = util.GetFullRequestURL(baseURL, requestURL, channelType)
+			fullRequestURL = getFullRequestURL(baseURL, requestURL, channelType)
 		}
 	case APITypeClaude:
 		fullRequestURL = "https://api.anthropic.com/v1/complete"
@@ -163,8 +171,8 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 		apiKey := c.Request.Header.Get("Authorization")
 		apiKey = strings.TrimPrefix(apiKey, "Bearer ")
 		var err error
-		if apiKey, err = baidu.GetAccessToken(apiKey); err != nil {
-			return openai.ErrorWrapper(err, "invalid_baidu_config", http.StatusInternalServerError)
+		if apiKey, err = getBaiduAccessToken(apiKey); err != nil {
+			return errorWrapper(err, "invalid_baidu_config", http.StatusInternalServerError)
 		}
 		fullRequestURL += "?access_token=" + apiKey
 	case APITypePaLM:
@@ -194,7 +202,7 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 		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 == constant.RelayModeEmbeddings {
+		if relayMode == RelayModeEmbeddings {
 			fullRequestURL = "https://dashscope.aliyuncs.com/api/v1/services/embeddings/text-embedding/text-embedding"
 		}
 	case APITypeTencent:
@@ -205,12 +213,12 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 	var promptTokens int
 	var completionTokens int
 	switch relayMode {
-	case constant.RelayModeChatCompletions:
-		promptTokens = openai.CountTokenMessages(textRequest.Messages, textRequest.Model)
-	case constant.RelayModeCompletions:
-		promptTokens = openai.CountTokenInput(textRequest.Prompt, textRequest.Model)
-	case constant.RelayModeModerations:
-		promptTokens = openai.CountTokenInput(textRequest.Input, textRequest.Model)
+	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 {
@@ -222,14 +230,14 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 	preConsumedQuota := int(float64(preConsumedTokens) * ratio)
 	userQuota, err := model.CacheGetUserQuota(userId)
 	if err != nil {
-		return openai.ErrorWrapper(err, "get_user_quota_failed", http.StatusInternalServerError)
+		return errorWrapper(err, "get_user_quota_failed", http.StatusInternalServerError)
 	}
 	if userQuota-preConsumedQuota < 0 {
-		return openai.ErrorWrapper(errors.New("user quota is not enough"), "insufficient_user_quota", http.StatusForbidden)
+		return errorWrapper(errors.New("user quota is not enough"), "insufficient_user_quota", http.StatusForbidden)
 	}
 	err = model.CacheDecreaseUserQuota(userId, preConsumedQuota)
 	if err != nil {
-		return openai.ErrorWrapper(err, "decrease_user_quota_failed", http.StatusInternalServerError)
+		return errorWrapper(err, "decrease_user_quota_failed", http.StatusInternalServerError)
 	}
 	if userQuota > 100*preConsumedQuota {
 		// in this case, we do not pre-consume quota
@@ -240,14 +248,14 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 	if preConsumedQuota > 0 {
 		err := model.PreConsumeTokenQuota(tokenId, preConsumedQuota)
 		if err != nil {
-			return openai.ErrorWrapper(err, "pre_consume_token_quota_failed", http.StatusForbidden)
+			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 openai.ErrorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
+			return errorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
 		}
 		requestBody = bytes.NewBuffer(jsonStr)
 	} else {
@@ -255,86 +263,86 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 	}
 	switch apiType {
 	case APITypeClaude:
-		claudeRequest := anthropic.ConvertRequest(textRequest)
+		claudeRequest := requestOpenAI2Claude(textRequest)
 		jsonStr, err := json.Marshal(claudeRequest)
 		if err != nil {
-			return openai.ErrorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
+			return errorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
 		}
 		requestBody = bytes.NewBuffer(jsonStr)
 	case APITypeBaidu:
 		var jsonData []byte
 		var err error
 		switch relayMode {
-		case constant.RelayModeEmbeddings:
-			baiduEmbeddingRequest := baidu.ConvertEmbeddingRequest(textRequest)
+		case RelayModeEmbeddings:
+			baiduEmbeddingRequest := embeddingRequestOpenAI2Baidu(textRequest)
 			jsonData, err = json.Marshal(baiduEmbeddingRequest)
 		default:
-			baiduRequest := baidu.ConvertRequest(textRequest)
+			baiduRequest := requestOpenAI2Baidu(textRequest)
 			jsonData, err = json.Marshal(baiduRequest)
 		}
 		if err != nil {
-			return openai.ErrorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
+			return errorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
 		}
 		requestBody = bytes.NewBuffer(jsonData)
 	case APITypePaLM:
-		palmRequest := google.ConvertPaLMRequest(textRequest)
+		palmRequest := requestOpenAI2PaLM(textRequest)
 		jsonStr, err := json.Marshal(palmRequest)
 		if err != nil {
-			return openai.ErrorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
+			return errorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
 		}
 		requestBody = bytes.NewBuffer(jsonStr)
 	case APITypeGemini:
-		geminiChatRequest := google.ConvertGeminiRequest(textRequest)
+		geminiChatRequest := requestOpenAI2Gemini(textRequest)
 		jsonStr, err := json.Marshal(geminiChatRequest)
 		if err != nil {
-			return openai.ErrorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
+			return errorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
 		}
 		requestBody = bytes.NewBuffer(jsonStr)
 	case APITypeZhipu:
-		zhipuRequest := zhipu.ConvertRequest(textRequest)
+		zhipuRequest := requestOpenAI2Zhipu(textRequest)
 		jsonStr, err := json.Marshal(zhipuRequest)
 		if err != nil {
-			return openai.ErrorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
+			return errorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
 		}
 		requestBody = bytes.NewBuffer(jsonStr)
 	case APITypeAli:
 		var jsonStr []byte
 		var err error
 		switch relayMode {
-		case constant.RelayModeEmbeddings:
-			aliEmbeddingRequest := ali.ConvertEmbeddingRequest(textRequest)
+		case RelayModeEmbeddings:
+			aliEmbeddingRequest := embeddingRequestOpenAI2Ali(textRequest)
 			jsonStr, err = json.Marshal(aliEmbeddingRequest)
 		default:
-			aliRequest := ali.ConvertRequest(textRequest)
+			aliRequest := requestOpenAI2Ali(textRequest)
 			jsonStr, err = json.Marshal(aliRequest)
 		}
 		if err != nil {
-			return openai.ErrorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
+			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 := tencent.ParseConfig(apiKey)
+		appId, secretId, secretKey, err := parseTencentConfig(apiKey)
 		if err != nil {
-			return openai.ErrorWrapper(err, "invalid_tencent_config", http.StatusInternalServerError)
+			return errorWrapper(err, "invalid_tencent_config", http.StatusInternalServerError)
 		}
-		tencentRequest := tencent.ConvertRequest(textRequest)
+		tencentRequest := requestOpenAI2Tencent(textRequest)
 		tencentRequest.AppId = appId
 		tencentRequest.SecretId = secretId
 		jsonStr, err := json.Marshal(tencentRequest)
 		if err != nil {
-			return openai.ErrorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
+			return errorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
 		}
-		sign := tencent.GetSign(*tencentRequest, secretKey)
+		sign := getTencentSign(*tencentRequest, secretKey)
 		c.Request.Header.Set("Authorization", sign)
 		requestBody = bytes.NewBuffer(jsonStr)
 	case APITypeAIProxyLibrary:
-		aiProxyLibraryRequest := aiproxy.ConvertRequest(textRequest)
+		aiProxyLibraryRequest := requestOpenAI2AIProxyLibrary(textRequest)
 		aiProxyLibraryRequest.LibraryId = c.GetString("library_id")
 		jsonStr, err := json.Marshal(aiProxyLibraryRequest)
 		if err != nil {
-			return openai.ErrorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
+			return errorWrapper(err, "marshal_text_request_failed", http.StatusInternalServerError)
 		}
 		requestBody = bytes.NewBuffer(jsonStr)
 	}
@@ -346,7 +354,7 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 	if apiType != APITypeXunfei { // cause xunfei use websocket
 		req, err = http.NewRequest(c.Request.Method, fullRequestURL, requestBody)
 		if err != nil {
-			return openai.ErrorWrapper(err, "new_request_failed", http.StatusInternalServerError)
+			return errorWrapper(err, "new_request_failed", http.StatusInternalServerError)
 		}
 		apiKey := c.Request.Header.Get("Authorization")
 		apiKey = strings.TrimPrefix(apiKey, "Bearer ")
@@ -369,7 +377,7 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 			}
 			req.Header.Set("anthropic-version", anthropicVersion)
 		case APITypeZhipu:
-			token := zhipu.GetToken(apiKey)
+			token := getZhipuToken(apiKey)
 			req.Header.Set("Authorization", token)
 		case APITypeAli:
 			req.Header.Set("Authorization", "Bearer "+apiKey)
@@ -394,17 +402,17 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 			req.Header.Set("Accept", "text/event-stream")
 		}
 		//req.Header.Set("Connection", c.Request.Header.Get("Connection"))
-		resp, err = util.HTTPClient.Do(req)
+		resp, err = httpClient.Do(req)
 		if err != nil {
-			return openai.ErrorWrapper(err, "do_request_failed", http.StatusInternalServerError)
+			return errorWrapper(err, "do_request_failed", http.StatusInternalServerError)
 		}
 		err = req.Body.Close()
 		if err != nil {
-			return openai.ErrorWrapper(err, "close_request_body_failed", http.StatusInternalServerError)
+			return errorWrapper(err, "close_request_body_failed", http.StatusInternalServerError)
 		}
 		err = c.Request.Body.Close()
 		if err != nil {
-			return openai.ErrorWrapper(err, "close_request_body_failed", http.StatusInternalServerError)
+			return errorWrapper(err, "close_request_body_failed", http.StatusInternalServerError)
 		}
 		isStream = isStream || strings.HasPrefix(resp.Header.Get("Content-Type"), "text/event-stream")
 
@@ -418,11 +426,11 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 					}
 				}(c.Request.Context())
 			}
-			return util.RelayErrorHandler(resp)
+			return relayErrorHandler(resp)
 		}
 	}
 
-	var textResponse openai.SlimTextResponse
+	var textResponse TextResponse
 	tokenName := c.GetString("token_name")
 
 	defer func(ctx context.Context) {
@@ -463,15 +471,15 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 	switch apiType {
 	case APITypeOpenAI:
 		if isStream {
-			err, responseText := openai.StreamHandler(c, resp, relayMode)
+			err, responseText := openaiStreamHandler(c, resp, relayMode)
 			if err != nil {
 				return err
 			}
 			textResponse.Usage.PromptTokens = promptTokens
-			textResponse.Usage.CompletionTokens = openai.CountTokenText(responseText, textRequest.Model)
+			textResponse.Usage.CompletionTokens = countTokenText(responseText, textRequest.Model)
 			return nil
 		} else {
-			err, usage := openai.Handler(c, resp, promptTokens, textRequest.Model)
+			err, usage := openaiHandler(c, resp, promptTokens, textRequest.Model)
 			if err != nil {
 				return err
 			}
@@ -482,15 +490,15 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 		}
 	case APITypeClaude:
 		if isStream {
-			err, responseText := anthropic.StreamHandler(c, resp)
+			err, responseText := claudeStreamHandler(c, resp)
 			if err != nil {
 				return err
 			}
 			textResponse.Usage.PromptTokens = promptTokens
-			textResponse.Usage.CompletionTokens = openai.CountTokenText(responseText, textRequest.Model)
+			textResponse.Usage.CompletionTokens = countTokenText(responseText, textRequest.Model)
 			return nil
 		} else {
-			err, usage := anthropic.Handler(c, resp, promptTokens, textRequest.Model)
+			err, usage := claudeHandler(c, resp, promptTokens, textRequest.Model)
 			if err != nil {
 				return err
 			}
@@ -501,7 +509,7 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 		}
 	case APITypeBaidu:
 		if isStream {
-			err, usage := baidu.StreamHandler(c, resp)
+			err, usage := baiduStreamHandler(c, resp)
 			if err != nil {
 				return err
 			}
@@ -510,13 +518,13 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 			}
 			return nil
 		} else {
-			var err *openai.ErrorWithStatusCode
-			var usage *openai.Usage
+			var err *OpenAIErrorWithStatusCode
+			var usage *Usage
 			switch relayMode {
-			case constant.RelayModeEmbeddings:
-				err, usage = baidu.EmbeddingHandler(c, resp)
+			case RelayModeEmbeddings:
+				err, usage = baiduEmbeddingHandler(c, resp)
 			default:
-				err, usage = baidu.Handler(c, resp)
+				err, usage = baiduHandler(c, resp)
 			}
 			if err != nil {
 				return err
@@ -528,15 +536,15 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 		}
 	case APITypePaLM:
 		if textRequest.Stream { // PaLM2 API does not support stream
-			err, responseText := google.PaLMStreamHandler(c, resp)
+			err, responseText := palmStreamHandler(c, resp)
 			if err != nil {
 				return err
 			}
 			textResponse.Usage.PromptTokens = promptTokens
-			textResponse.Usage.CompletionTokens = openai.CountTokenText(responseText, textRequest.Model)
+			textResponse.Usage.CompletionTokens = countTokenText(responseText, textRequest.Model)
 			return nil
 		} else {
-			err, usage := google.PaLMHandler(c, resp, promptTokens, textRequest.Model)
+			err, usage := palmHandler(c, resp, promptTokens, textRequest.Model)
 			if err != nil {
 				return err
 			}
@@ -547,15 +555,15 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 		}
 	case APITypeGemini:
 		if textRequest.Stream {
-			err, responseText := google.StreamHandler(c, resp)
+			err, responseText := geminiChatStreamHandler(c, resp)
 			if err != nil {
 				return err
 			}
 			textResponse.Usage.PromptTokens = promptTokens
-			textResponse.Usage.CompletionTokens = openai.CountTokenText(responseText, textRequest.Model)
+			textResponse.Usage.CompletionTokens = countTokenText(responseText, textRequest.Model)
 			return nil
 		} else {
-			err, usage := google.GeminiHandler(c, resp, promptTokens, textRequest.Model)
+			err, usage := geminiChatHandler(c, resp, promptTokens, textRequest.Model)
 			if err != nil {
 				return err
 			}
@@ -566,7 +574,7 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 		}
 	case APITypeZhipu:
 		if isStream {
-			err, usage := zhipu.StreamHandler(c, resp)
+			err, usage := zhipuStreamHandler(c, resp)
 			if err != nil {
 				return err
 			}
@@ -577,7 +585,7 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 			textResponse.Usage.PromptTokens = textResponse.Usage.TotalTokens
 			return nil
 		} else {
-			err, usage := zhipu.Handler(c, resp)
+			err, usage := zhipuHandler(c, resp)
 			if err != nil {
 				return err
 			}
@@ -590,7 +598,7 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 		}
 	case APITypeAli:
 		if isStream {
-			err, usage := ali.StreamHandler(c, resp)
+			err, usage := aliStreamHandler(c, resp)
 			if err != nil {
 				return err
 			}
@@ -599,13 +607,13 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 			}
 			return nil
 		} else {
-			var err *openai.ErrorWithStatusCode
-			var usage *openai.Usage
+			var err *OpenAIErrorWithStatusCode
+			var usage *Usage
 			switch relayMode {
-			case constant.RelayModeEmbeddings:
-				err, usage = ali.EmbeddingHandler(c, resp)
+			case RelayModeEmbeddings:
+				err, usage = aliEmbeddingHandler(c, resp)
 			default:
-				err, usage = ali.Handler(c, resp)
+				err, usage = aliHandler(c, resp)
 			}
 			if err != nil {
 				return err
@@ -620,14 +628,14 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 		auth = strings.TrimPrefix(auth, "Bearer ")
 		splits := strings.Split(auth, "|")
 		if len(splits) != 3 {
-			return openai.ErrorWrapper(errors.New("invalid auth"), "invalid_auth", http.StatusBadRequest)
+			return errorWrapper(errors.New("invalid auth"), "invalid_auth", http.StatusBadRequest)
 		}
-		var err *openai.ErrorWithStatusCode
-		var usage *openai.Usage
+		var err *OpenAIErrorWithStatusCode
+		var usage *Usage
 		if isStream {
-			err, usage = xunfei.StreamHandler(c, textRequest, splits[0], splits[1], splits[2])
+			err, usage = xunfeiStreamHandler(c, textRequest, splits[0], splits[1], splits[2])
 		} else {
-			err, usage = xunfei.Handler(c, textRequest, splits[0], splits[1], splits[2])
+			err, usage = xunfeiHandler(c, textRequest, splits[0], splits[1], splits[2])
 		}
 		if err != nil {
 			return err
@@ -638,7 +646,7 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 		return nil
 	case APITypeAIProxyLibrary:
 		if isStream {
-			err, usage := aiproxy.StreamHandler(c, resp)
+			err, usage := aiProxyLibraryStreamHandler(c, resp)
 			if err != nil {
 				return err
 			}
@@ -647,7 +655,7 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 			}
 			return nil
 		} else {
-			err, usage := aiproxy.Handler(c, resp)
+			err, usage := aiProxyLibraryHandler(c, resp)
 			if err != nil {
 				return err
 			}
@@ -658,15 +666,15 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 		}
 	case APITypeTencent:
 		if isStream {
-			err, responseText := tencent.StreamHandler(c, resp)
+			err, responseText := tencentStreamHandler(c, resp)
 			if err != nil {
 				return err
 			}
 			textResponse.Usage.PromptTokens = promptTokens
-			textResponse.Usage.CompletionTokens = openai.CountTokenText(responseText, textRequest.Model)
+			textResponse.Usage.CompletionTokens = countTokenText(responseText, textRequest.Model)
 			return nil
 		} else {
-			err, usage := tencent.Handler(c, resp)
+			err, usage := tencentHandler(c, resp)
 			if err != nil {
 				return err
 			}
@@ -676,6 +684,6 @@ func RelayTextHelper(c *gin.Context, relayMode int) *openai.ErrorWithStatusCode
 			return nil
 		}
 	default:
-		return openai.ErrorWrapper(errors.New("unknown api type"), "unknown_api_type", http.StatusInternalServerError)
+		return errorWrapper(errors.New("unknown api type"), "unknown_api_type", http.StatusInternalServerError)
 	}
 }

controller/relay-utils.go

@@ -1,15 +1,25 @@
-package openai
+package controller
 
 import (
+	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/pkoukk/tiktoken-go"
+	"io"
 	"math"
+	"net/http"
 	"one-api/common"
 	"one-api/common/image"
+	"one-api/model"
+	"strconv"
 	"strings"
+
+	"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
@@ -61,7 +71,7 @@ func getTokenNum(tokenEncoder *tiktoken.Tiktoken, text string) int {
 	return len(tokenEncoder.Encode(text, nil, nil))
 }
 
-func CountTokenMessages(messages []Message, model string) int {
+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
@@ -185,21 +195,191 @@ func countImageTokens(url string, detail string) (_ int, err error) {
 	}
 }
 
-func CountTokenInput(input any, model string) int {
+func countTokenInput(input any, model string) int {
 	switch v := input.(type) {
 	case string:
-		return CountTokenText(v, model)
+		return countTokenText(v, model)
 	case []string:
 		text := ""
 		for _, s := range v {
 			text += s
 		}
-		return CountTokenText(text, model)
+		return countTokenText(text, model)
 	}
 	return 0
 }
 
-func CountTokenText(text string, model string) int {
+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,4 +1,4 @@
-package xunfei
+package controller
 
 import (
 	"crypto/hmac"
@@ -12,8 +12,6 @@ import (
 	"net/http"
 	"net/url"
 	"one-api/common"
-	"one-api/relay/channel/openai"
-	"one-api/relay/constant"
 	"strings"
 	"time"
 )
@@ -21,26 +19,82 @@ import (
 // https://console.xfyun.cn/services/cbm
 // https://www.xfyun.cn/doc/spark/Web.html
 
-func requestOpenAI2Xunfei(request openai.GeneralOpenAIRequest, xunfeiAppId string, domain string) *ChatRequest {
-	messages := make([]Message, 0, len(request.Messages))
+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, Message{
+			messages = append(messages, XunfeiMessage{
 				Role:    "user",
 				Content: message.StringContent(),
 			})
-			messages = append(messages, Message{
+			messages = append(messages, XunfeiMessage{
 				Role:    "assistant",
 				Content: "Okay",
 			})
 		} else {
-			messages = append(messages, Message{
+			messages = append(messages, XunfeiMessage{
 				Role:    message.Role,
 				Content: message.StringContent(),
 			})
 		}
 	}
-	xunfeiRequest := ChatRequest{}
+	xunfeiRequest := XunfeiChatRequest{}
 	xunfeiRequest.Header.AppId = xunfeiAppId
 	xunfeiRequest.Parameter.Chat.Domain = domain
 	xunfeiRequest.Parameter.Chat.Temperature = request.Temperature
@@ -50,49 +104,49 @@ func requestOpenAI2Xunfei(request openai.GeneralOpenAIRequest, xunfeiAppId strin
 	return &xunfeiRequest
 }
 
-func responseXunfei2OpenAI(response *ChatResponse) *openai.TextResponse {
+func responseXunfei2OpenAI(response *XunfeiChatResponse) *OpenAITextResponse {
 	if len(response.Payload.Choices.Text) == 0 {
-		response.Payload.Choices.Text = []ChatResponseTextItem{
+		response.Payload.Choices.Text = []XunfeiChatResponseTextItem{
 			{
 				Content: "",
 			},
 		}
 	}
-	choice := openai.TextResponseChoice{
+	choice := OpenAITextResponseChoice{
 		Index: 0,
-		Message: openai.Message{
+		Message: Message{
 			Role:    "assistant",
 			Content: response.Payload.Choices.Text[0].Content,
 		},
-		FinishReason: constant.StopFinishReason,
+		FinishReason: stopFinishReason,
 	}
-	fullTextResponse := openai.TextResponse{
+	fullTextResponse := OpenAITextResponse{
 		Object:  "chat.completion",
 		Created: common.GetTimestamp(),
-		Choices: []openai.TextResponseChoice{choice},
+		Choices: []OpenAITextResponseChoice{choice},
 		Usage:   response.Payload.Usage.Text,
 	}
 	return &fullTextResponse
 }
 
-func streamResponseXunfei2OpenAI(xunfeiResponse *ChatResponse) *openai.ChatCompletionsStreamResponse {
+func streamResponseXunfei2OpenAI(xunfeiResponse *XunfeiChatResponse) *ChatCompletionsStreamResponse {
 	if len(xunfeiResponse.Payload.Choices.Text) == 0 {
-		xunfeiResponse.Payload.Choices.Text = []ChatResponseTextItem{
+		xunfeiResponse.Payload.Choices.Text = []XunfeiChatResponseTextItem{
 			{
 				Content: "",
 			},
 		}
 	}
-	var choice openai.ChatCompletionsStreamResponseChoice
+	var choice ChatCompletionsStreamResponseChoice
 	choice.Delta.Content = xunfeiResponse.Payload.Choices.Text[0].Content
 	if xunfeiResponse.Payload.Choices.Status == 2 {
-		choice.FinishReason = &constant.StopFinishReason
+		choice.FinishReason = &stopFinishReason
 	}
-	response := openai.ChatCompletionsStreamResponse{
+	response := ChatCompletionsStreamResponse{
 		Object:  "chat.completion.chunk",
 		Created: common.GetTimestamp(),
 		Model:   "SparkDesk",
-		Choices: []openai.ChatCompletionsStreamResponseChoice{choice},
+		Choices: []ChatCompletionsStreamResponseChoice{choice},
 	}
 	return &response
 }
@@ -123,14 +177,14 @@ func buildXunfeiAuthUrl(hostUrl string, apiKey, apiSecret string) string {
 	return callUrl
 }
 
-func StreamHandler(c *gin.Context, textRequest openai.GeneralOpenAIRequest, appId string, apiSecret string, apiKey string) (*openai.ErrorWithStatusCode, *openai.Usage) {
+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 openai.ErrorWrapper(err, "make xunfei request err", http.StatusInternalServerError), nil
+		return errorWrapper(err, "make xunfei request err", http.StatusInternalServerError), nil
 	}
-	common.SetEventStreamHeaders(c)
-	var usage openai.Usage
+	setEventStreamHeaders(c)
+	var usage Usage
 	c.Stream(func(w io.Writer) bool {
 		select {
 		case xunfeiResponse := <-dataChan:
@@ -153,15 +207,15 @@ func StreamHandler(c *gin.Context, textRequest openai.GeneralOpenAIRequest, appI
 	return nil, &usage
 }
 
-func Handler(c *gin.Context, textRequest openai.GeneralOpenAIRequest, appId string, apiSecret string, apiKey string) (*openai.ErrorWithStatusCode, *openai.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 openai.ErrorWrapper(err, "make xunfei request err", http.StatusInternalServerError), nil
+		return errorWrapper(err, "make xunfei request err", http.StatusInternalServerError), nil
 	}
-	var usage openai.Usage
+	var usage Usage
 	var content string
-	var xunfeiResponse ChatResponse
+	var xunfeiResponse XunfeiChatResponse
 	stop := false
 	for !stop {
 		select {
@@ -177,7 +231,7 @@ func Handler(c *gin.Context, textRequest openai.GeneralOpenAIRequest, appId stri
 		}
 	}
 	if len(xunfeiResponse.Payload.Choices.Text) == 0 {
-		xunfeiResponse.Payload.Choices.Text = []ChatResponseTextItem{
+		xunfeiResponse.Payload.Choices.Text = []XunfeiChatResponseTextItem{
 			{
 				Content: "",
 			},
@@ -188,14 +242,14 @@ func Handler(c *gin.Context, textRequest openai.GeneralOpenAIRequest, appId stri
 	response := responseXunfei2OpenAI(&xunfeiResponse)
 	jsonResponse, err := json.Marshal(response)
 	if err != nil {
-		return openai.ErrorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), 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 openai.GeneralOpenAIRequest, domain, authUrl, appId string) (chan ChatResponse, chan bool, error) {
+func xunfeiMakeRequest(textRequest GeneralOpenAIRequest, domain, authUrl, appId string) (chan XunfeiChatResponse, chan bool, error) {
 	d := websocket.Dialer{
 		HandshakeTimeout: 5 * time.Second,
 	}
@@ -209,7 +263,7 @@ func xunfeiMakeRequest(textRequest openai.GeneralOpenAIRequest, domain, authUrl,
 		return nil, nil, err
 	}
 
-	dataChan := make(chan ChatResponse)
+	dataChan := make(chan XunfeiChatResponse)
 	stopChan := make(chan bool)
 	go func() {
 		for {
@@ -218,7 +272,7 @@ func xunfeiMakeRequest(textRequest openai.GeneralOpenAIRequest, domain, authUrl,
 				common.SysError("error reading stream response: " + err.Error())
 				break
 			}
-			var response ChatResponse
+			var response XunfeiChatResponse
 			err = json.Unmarshal(msg, &response)
 			if err != nil {
 				common.SysError("error unmarshalling stream response: " + err.Error())

controller/relay-zhipu.go

@@ -1,4 +1,4 @@
-package zhipu
+package controller
 
 import (
 	"bufio"
@@ -8,8 +8,6 @@ import (
 	"io"
 	"net/http"
 	"one-api/common"
-	"one-api/relay/channel/openai"
-	"one-api/relay/constant"
 	"strings"
 	"sync"
 	"time"
@@ -20,13 +18,53 @@ import (
 // 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 GetToken(apikey string) string {
+func getZhipuToken(apikey string) string {
 	data, ok := zhipuTokens.Load(apikey)
 	if ok {
-		tokenData := data.(tokenData)
+		tokenData := data.(zhipuTokenData)
 		if time.Now().Before(tokenData.ExpiryTime) {
 			return tokenData.Token
 		}
@@ -62,7 +100,7 @@ func GetToken(apikey string) string {
 		return ""
 	}
 
-	zhipuTokens.Store(apikey, tokenData{
+	zhipuTokens.Store(apikey, zhipuTokenData{
 		Token:      tokenString,
 		ExpiryTime: expiryTime,
 	})
@@ -70,26 +108,26 @@ func GetToken(apikey string) string {
 	return tokenString
 }
 
-func ConvertRequest(request openai.GeneralOpenAIRequest) *Request {
-	messages := make([]Message, 0, len(request.Messages))
+func requestOpenAI2Zhipu(request GeneralOpenAIRequest) *ZhipuRequest {
+	messages := make([]ZhipuMessage, 0, len(request.Messages))
 	for _, message := range request.Messages {
 		if message.Role == "system" {
-			messages = append(messages, Message{
+			messages = append(messages, ZhipuMessage{
 				Role:    "system",
 				Content: message.StringContent(),
 			})
-			messages = append(messages, Message{
+			messages = append(messages, ZhipuMessage{
 				Role:    "user",
 				Content: "Okay",
 			})
 		} else {
-			messages = append(messages, Message{
+			messages = append(messages, ZhipuMessage{
 				Role:    message.Role,
 				Content: message.StringContent(),
 			})
 		}
 	}
-	return &Request{
+	return &ZhipuRequest{
 		Prompt:      messages,
 		Temperature: request.Temperature,
 		TopP:        request.TopP,
@@ -97,18 +135,18 @@ func ConvertRequest(request openai.GeneralOpenAIRequest) *Request {
 	}
 }
 
-func responseZhipu2OpenAI(response *Response) *openai.TextResponse {
-	fullTextResponse := openai.TextResponse{
+func responseZhipu2OpenAI(response *ZhipuResponse) *OpenAITextResponse {
+	fullTextResponse := OpenAITextResponse{
 		Id:      response.Data.TaskId,
 		Object:  "chat.completion",
 		Created: common.GetTimestamp(),
-		Choices: make([]openai.TextResponseChoice, 0, len(response.Data.Choices)),
+		Choices: make([]OpenAITextResponseChoice, 0, len(response.Data.Choices)),
 		Usage:   response.Data.Usage,
 	}
 	for i, choice := range response.Data.Choices {
-		openaiChoice := openai.TextResponseChoice{
+		openaiChoice := OpenAITextResponseChoice{
 			Index: i,
-			Message: openai.Message{
+			Message: Message{
 				Role:    choice.Role,
 				Content: strings.Trim(choice.Content, "\""),
 			},
@@ -122,34 +160,34 @@ func responseZhipu2OpenAI(response *Response) *openai.TextResponse {
 	return &fullTextResponse
 }
 
-func streamResponseZhipu2OpenAI(zhipuResponse string) *openai.ChatCompletionsStreamResponse {
-	var choice openai.ChatCompletionsStreamResponseChoice
+func streamResponseZhipu2OpenAI(zhipuResponse string) *ChatCompletionsStreamResponse {
+	var choice ChatCompletionsStreamResponseChoice
 	choice.Delta.Content = zhipuResponse
-	response := openai.ChatCompletionsStreamResponse{
+	response := ChatCompletionsStreamResponse{
 		Object:  "chat.completion.chunk",
 		Created: common.GetTimestamp(),
 		Model:   "chatglm",
-		Choices: []openai.ChatCompletionsStreamResponseChoice{choice},
+		Choices: []ChatCompletionsStreamResponseChoice{choice},
 	}
 	return &response
 }
 
-func streamMetaResponseZhipu2OpenAI(zhipuResponse *StreamMetaResponse) (*openai.ChatCompletionsStreamResponse, *openai.Usage) {
-	var choice openai.ChatCompletionsStreamResponseChoice
+func streamMetaResponseZhipu2OpenAI(zhipuResponse *ZhipuStreamMetaResponse) (*ChatCompletionsStreamResponse, *Usage) {
+	var choice ChatCompletionsStreamResponseChoice
 	choice.Delta.Content = ""
-	choice.FinishReason = &constant.StopFinishReason
-	response := openai.ChatCompletionsStreamResponse{
+	choice.FinishReason = &stopFinishReason
+	response := ChatCompletionsStreamResponse{
 		Id:      zhipuResponse.RequestId,
 		Object:  "chat.completion.chunk",
 		Created: common.GetTimestamp(),
 		Model:   "chatglm",
-		Choices: []openai.ChatCompletionsStreamResponseChoice{choice},
+		Choices: []ChatCompletionsStreamResponseChoice{choice},
 	}
 	return &response, &zhipuResponse.Usage
 }
 
-func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode, *openai.Usage) {
-	var usage *openai.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 {
@@ -186,7 +224,7 @@ func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatus
 		}
 		stopChan <- true
 	}()
-	common.SetEventStreamHeaders(c)
+	setEventStreamHeaders(c)
 	c.Stream(func(w io.Writer) bool {
 		select {
 		case data := <-dataChan:
@@ -199,7 +237,7 @@ func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatus
 			c.Render(-1, common.CustomEvent{Data: "data: " + string(jsonResponse)})
 			return true
 		case data := <-metaChan:
-			var zhipuResponse StreamMetaResponse
+			var zhipuResponse ZhipuStreamMetaResponse
 			err := json.Unmarshal([]byte(data), &zhipuResponse)
 			if err != nil {
 				common.SysError("error unmarshalling stream response: " + err.Error())
@@ -221,28 +259,28 @@ func StreamHandler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatus
 	})
 	err := resp.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
 	}
 	return nil, usage
 }
 
-func Handler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode, *openai.Usage) {
-	var zhipuResponse Response
+func zhipuHandler(c *gin.Context, resp *http.Response) (*OpenAIErrorWithStatusCode, *Usage) {
+	var zhipuResponse ZhipuResponse
 	responseBody, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return openai.ErrorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
 	}
 	err = resp.Body.Close()
 	if err != nil {
-		return openai.ErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
 	}
 	err = json.Unmarshal(responseBody, &zhipuResponse)
 	if err != nil {
-		return openai.ErrorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
 	}
 	if !zhipuResponse.Success {
-		return &openai.ErrorWithStatusCode{
-			Error: openai.Error{
+		return &OpenAIErrorWithStatusCode{
+			OpenAIError: OpenAIError{
 				Message: zhipuResponse.Msg,
 				Type:    "zhipu_error",
 				Param:   "",
@@ -255,7 +293,7 @@ func Handler(c *gin.Context, resp *http.Response) (*openai.ErrorWithStatusCode,
 	fullTextResponse.Model = "chatglm"
 	jsonResponse, err := json.Marshal(fullTextResponse)
 	if err != nil {
-		return openai.ErrorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
+		return errorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
 	}
 	c.Writer.Header().Set("Content-Type", "application/json")
 	c.Writer.WriteHeader(resp.StatusCode)

controller/relay.go

@@ -4,53 +4,349 @@ import (
 	"fmt"
 	"net/http"
 	"one-api/common"
-	"one-api/relay/channel/openai"
-	"one-api/relay/constant"
-	"one-api/relay/controller"
-	"one-api/relay/util"
 	"strconv"
 	"strings"
 
 	"github.com/gin-gonic/gin"
 )
 
+type Message struct {
+	Role    string  `json:"role"`
+	Content any     `json:"content"`
+	Name    *string `json:"name,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
+)
+
 // https://platform.openai.com/docs/api-reference/chat
 
-func Relay(c *gin.Context) {
-	relayMode := constant.RelayModeUnknown
-	if strings.HasPrefix(c.Request.URL.Path, "/v1/chat/completions") {
-		relayMode = constant.RelayModeChatCompletions
-	} else if strings.HasPrefix(c.Request.URL.Path, "/v1/completions") {
-		relayMode = constant.RelayModeCompletions
-	} else if strings.HasPrefix(c.Request.URL.Path, "/v1/embeddings") {
-		relayMode = constant.RelayModeEmbeddings
-	} else if strings.HasSuffix(c.Request.URL.Path, "embeddings") {
-		relayMode = constant.RelayModeEmbeddings
-	} else if strings.HasPrefix(c.Request.URL.Path, "/v1/moderations") {
-		relayMode = constant.RelayModeModerations
-	} else if strings.HasPrefix(c.Request.URL.Path, "/v1/images/generations") {
-		relayMode = constant.RelayModeImagesGenerations
-	} else if strings.HasPrefix(c.Request.URL.Path, "/v1/edits") {
-		relayMode = constant.RelayModeEdits
-	} else if strings.HasPrefix(c.Request.URL.Path, "/v1/audio/speech") {
-		relayMode = constant.RelayModeAudioSpeech
-	} else if strings.HasPrefix(c.Request.URL.Path, "/v1/audio/transcriptions") {
-		relayMode = constant.RelayModeAudioTranscription
-	} else if strings.HasPrefix(c.Request.URL.Path, "/v1/audio/translations") {
-		relayMode = constant.RelayModeAudioTranslation
+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) ParseInput() []string {
+	if r.Input == nil {
+		return nil
 	}
-	var err *openai.ErrorWithStatusCode
+	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"`
+}
+
+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
 	switch relayMode {
-	case constant.RelayModeImagesGenerations:
-		err = controller.RelayImageHelper(c, relayMode)
-	case constant.RelayModeAudioSpeech:
+	case RelayModeImagesGenerations:
+		err = relayImageHelper(c, relayMode)
+	case RelayModeAudioSpeech:
 		fallthrough
-	case constant.RelayModeAudioTranslation:
+	case RelayModeAudioTranslation:
 		fallthrough
-	case constant.RelayModeAudioTranscription:
-		err = controller.RelayAudioHelper(c, relayMode)
+	case RelayModeAudioTranscription:
+		err = relayAudioHelper(c, relayMode)
 	default:
-		err = controller.RelayTextHelper(c, relayMode)
+		err = relayTextHelper(c, relayMode)
 	}
 	if err != nil {
 		requestId := c.GetString(common.RequestIdKey)
@@ -63,17 +359,17 @@ func Relay(c *gin.Context) {
 			c.Redirect(http.StatusTemporaryRedirect, fmt.Sprintf("%s?retry=%d", c.Request.URL.Path, retryTimes-1))
 		} else {
 			if err.StatusCode == http.StatusTooManyRequests {
-				err.Error.Message = "当前分组上游负载已饱和，请稍后再试"
+				err.OpenAIError.Message = "当前分组上游负载已饱和，请稍后再试"
 			}
-			err.Error.Message = common.MessageWithRequestId(err.Error.Message, requestId)
+			err.OpenAIError.Message = common.MessageWithRequestId(err.OpenAIError.Message, requestId)
 			c.JSON(err.StatusCode, gin.H{
-				"error": err.Error,
+				"error": err.OpenAIError,
 			})
 		}
 		channelId := c.GetInt("channel_id")
 		common.LogError(c.Request.Context(), fmt.Sprintf("relay error (channel #%d): %s", channelId, err.Message))
 		// https://platform.openai.com/docs/guides/error-codes/api-errors
-		if util.ShouldDisableChannel(&err.Error, err.StatusCode) {
+		if shouldDisableChannel(&err.OpenAIError, err.StatusCode) {
 			channelId := c.GetInt("channel_id")
 			channelName := c.GetString("channel_name")
 			disableChannel(channelId, channelName, err.Message)
@@ -82,7 +378,7 @@ func Relay(c *gin.Context) {
 }
 
 func RelayNotImplemented(c *gin.Context) {
-	err := openai.Error{
+	err := OpenAIError{
 		Message: "API not implemented",
 		Type:    "one_api_error",
 		Param:   "",
@@ -94,7 +390,7 @@ func RelayNotImplemented(c *gin.Context) {
 }
 
 func RelayNotFound(c *gin.Context) {
-	err := openai.Error{
+	err := OpenAIError{
 		Message: fmt.Sprintf("Invalid URL (%s %s)", c.Request.Method, c.Request.URL.Path),
 		Type:    "invalid_request_error",
 		Param:   "",

i18n/en.json

@@ -330,6 +330,7 @@
   "通常和邮箱地址保持一致": "Usually consistent with the email address",
   "SMTP 访问凭证": "SMTP Access Credential",
   "敏感信息不会发送到前端显示": "Sensitive information will not be displayed in the frontend",
+  "使用 SMTP LOGIN 认证方式": "Use LOGIN as SMTP authentication method",
   "保存 SMTP 设置": "Save SMTP Settings",
   "配置 GitHub OAuth App": "Configure GitHub OAuth App",
   "用以支持通过 GitHub 进行登录注册": "To support login & registration via GitHub",

main.go

@@ -10,7 +10,6 @@ import (
 	"one-api/controller"
 	"one-api/middleware"
 	"one-api/model"
-	"one-api/relay/channel/openai"
 	"one-api/router"
 	"os"
 	"strconv"
@@ -81,7 +80,7 @@ func main() {
 		common.SysLog("batch update enabled with interval " + strconv.Itoa(common.BatchUpdateInterval) + "s")
 		model.InitBatchUpdater()
 	}
-	openai.InitTokenEncoders()
+	controller.InitTokenEncoders()
 
 	// Initialize HTTP server
 	server := gin.New()

model/log.go

@@ -9,9 +9,9 @@ import (
 )
 
 type Log struct {
-	Id               int    `json:"id"`
+	Id               int    `json:"id;index:idx_created_at_id,priority:1"`
 	UserId           int    `json:"user_id" gorm:"index"`
-	CreatedAt        int64  `json:"created_at" gorm:"bigint;index:idx_created_at_type"`
+	CreatedAt        int64  `json:"created_at" gorm:"bigint;index:idx_created_at_id,priority:2;index:idx_created_at_type"`
 	Type             int    `json:"type" gorm:"index:idx_created_at_type"`
 	Content          string `json:"content"`
 	Username         string `json:"username" gorm:"index:index_username_model_name,priority:2;default:''"`
@@ -72,7 +72,7 @@ func RecordConsumeLog(ctx context.Context, userId int, channelId int, promptToke
 	}
 }
 
-func GetAllLogs(logType int, startTimestamp int64, endTimestamp int64, modelName string, username string, tokenName string, startIdx int, num int, channel int) (logs []*Log, err error) {
+func GetAllLogs(logType int, startTimestamp int64, endTimestamp int64, modelName string, username string, tokenName string, startIdx int, num int, channels []int) (logs []*Log, err error) {
 	var tx *gorm.DB
 	if logType == LogTypeUnknown {
 		tx = DB
@@ -94,9 +94,12 @@ func GetAllLogs(logType int, startTimestamp int64, endTimestamp int64, modelName
 	if endTimestamp != 0 {
 		tx = tx.Where("created_at <= ?", endTimestamp)
 	}
-	if channel != 0 {
-		tx = tx.Where("channel_id = ?", channel)
+	if len(channels) > 1 {
+		tx = tx.Where("channel_id IN ?", channels)
+	} else if len(channels) == 1 && channels[0] != 0 {
+		tx = tx.Where("channel_id = ?", channels[0])
 	}
+
 	err = tx.Order("id desc").Limit(num).Offset(startIdx).Find(&logs).Error
 	return logs, err
 }
@@ -134,7 +137,7 @@ func SearchUserLogs(userId int, keyword string) (logs []*Log, err error) {
 	return logs, err
 }
 
-func SumUsedQuota(logType int, startTimestamp int64, endTimestamp int64, modelName string, username string, tokenName string, channel int) (quota int) {
+func SumUsedQuota(logType int, startTimestamp int64, endTimestamp int64, modelName string, username string, tokenName string, channels []int) (quota int) {
 	tx := DB.Table("logs").Select("ifnull(sum(quota),0)")
 	if username != "" {
 		tx = tx.Where("username = ?", username)
@@ -151,8 +154,10 @@ func SumUsedQuota(logType int, startTimestamp int64, endTimestamp int64, modelNa
 	if modelName != "" {
 		tx = tx.Where("model_name = ?", modelName)
 	}
-	if channel != 0 {
-		tx = tx.Where("channel_id = ?", channel)
+	if len(channels) > 1 {
+		tx = tx.Where("channel_id IN ?", channels)
+	} else if len(channels) == 1 && channels[0] != 0 {
+		tx = tx.Where("channel_id = ?", channels[0])
 	}
 	tx.Where("type = ?", LogTypeConsume).Scan(&quota)
 	return quota

model/main.go

@@ -16,7 +16,7 @@ var DB *gorm.DB
 
 func createRootAccountIfNeed() error {
 	var user User
-	//if user.Status != util.UserStatusEnabled {
+	//if user.Status != common.UserStatusEnabled {
 	if err := DB.First(&user).Error; err != nil {
 		common.SysLog("no user exists, create a root user for you: username is root, password is 123456")
 		hashedPassword, err := common.Password2Hash("123456")

model/option.go

@@ -47,6 +47,7 @@ func InitOptionMap() {
 	common.OptionMap["SMTPPort"] = strconv.Itoa(common.SMTPPort)
 	common.OptionMap["SMTPAccount"] = ""
 	common.OptionMap["SMTPToken"] = ""
+	common.OptionMap["SMTPAuthLoginEnabled"] = strconv.FormatBool(common.SMTPAuthLoginEnabled)
 	common.OptionMap["Notice"] = ""
 	common.OptionMap["About"] = ""
 	common.OptionMap["HomePageContent"] = ""
@@ -159,6 +160,8 @@ func updateOptionMap(key string, value string) (err error) {
 			common.DisplayInCurrencyEnabled = boolValue
 		case "DisplayTokenStatEnabled":
 			common.DisplayTokenStatEnabled = boolValue
+		case "SMTPAuthLoginEnabled":
+			common.SMTPAuthLoginEnabled = boolValue
 		}
 	}
 	switch key {

model/user.go

@@ -15,7 +15,7 @@ type User struct {
 	Username         string `json:"username" gorm:"unique;index" validate:"max=12"`
 	Password         string `json:"password" gorm:"not null;" validate:"min=8,max=20"`
 	DisplayName      string `json:"display_name" gorm:"index" validate:"max=20"`
-	Role             int    `json:"role" gorm:"type:int;default:1"`   // admin, util
+	Role             int    `json:"role" gorm:"type:int;default:1"`   // admin, common
 	Status           int    `json:"status" gorm:"type:int;default:1"` // enabled, disabled
 	Email            string `json:"email" gorm:"index" validate:"max=50"`
 	GitHubId         string `json:"github_id" gorm:"column:github_id;index"`
@@ -141,15 +141,7 @@ func (user *User) ValidateAndFill() (err error) {
 	if user.Username == "" || password == "" {
 		return errors.New("用户名或密码为空")
 	}
-	err = DB.Where("username = ?", user.Username).First(user).Error
-	if err != nil {
-		// we must make sure check username firstly
-		// consider this case: a malicious user set his username as other's email
-		err := DB.Where("email = ?", user.Username).First(user).Error
-		if err != nil {
-			return errors.New("用户名或密码错误，或用户已被封禁")
-		}
-	}
+	DB.Where(User{Username: user.Username}).First(user)
 	okay := common.ValidatePasswordAndHash(password, user.Password)
 	if !okay || user.Status != common.UserStatusEnabled {
 		return errors.New("用户名或密码错误，或用户已被封禁")

relay/channel/aiproxy/model.go

@@ -1,32 +0,0 @@
-package aiproxy
-
-type LibraryRequest struct {
-	Model     string `json:"model"`
-	Query     string `json:"query"`
-	LibraryId string `json:"libraryId"`
-	Stream    bool   `json:"stream"`
-}
-
-type LibraryError struct {
-	ErrCode int    `json:"errCode"`
-	Message string `json:"message"`
-}
-
-type LibraryDocument struct {
-	Title string `json:"title"`
-	URL   string `json:"url"`
-}
-
-type LibraryResponse struct {
-	Success   bool              `json:"success"`
-	Answer    string            `json:"answer"`
-	Documents []LibraryDocument `json:"documents"`
-	LibraryError
-}
-
-type LibraryStreamResponse struct {
-	Content   string            `json:"content"`
-	Finish    bool              `json:"finish"`
-	Model     string            `json:"model"`
-	Documents []LibraryDocument `json:"documents"`
-}

relay/channel/ali/model.go

@@ -1,71 +0,0 @@
-package ali
-
-type Message struct {
-	Content string `json:"content"`
-	Role    string `json:"role"`
-}
-
-type Input struct {
-	//Prompt   string       `json:"prompt"`
-	Messages []Message `json:"messages"`
-}
-
-type Parameters struct {
-	TopP              float64 `json:"top_p,omitempty"`
-	TopK              int     `json:"top_k,omitempty"`
-	Seed              uint64  `json:"seed,omitempty"`
-	EnableSearch      bool    `json:"enable_search,omitempty"`
-	IncrementalOutput bool    `json:"incremental_output,omitempty"`
-}
-
-type ChatRequest struct {
-	Model      string     `json:"model"`
-	Input      Input      `json:"input"`
-	Parameters Parameters `json:"parameters,omitempty"`
-}
-
-type EmbeddingRequest 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 Embedding struct {
-	Embedding []float64 `json:"embedding"`
-	TextIndex int       `json:"text_index"`
-}
-
-type EmbeddingResponse struct {
-	Output struct {
-		Embeddings []Embedding `json:"embeddings"`
-	} `json:"output"`
-	Usage Usage `json:"usage"`
-	Error
-}
-
-type Error struct {
-	Code      string `json:"code"`
-	Message   string `json:"message"`
-	RequestId string `json:"request_id"`
-}
-
-type Usage struct {
-	InputTokens  int `json:"input_tokens"`
-	OutputTokens int `json:"output_tokens"`
-	TotalTokens  int `json:"total_tokens"`
-}
-
-type Output struct {
-	Text         string `json:"text"`
-	FinishReason string `json:"finish_reason"`
-}
-
-type ChatResponse struct {
-	Output Output `json:"output"`
-	Usage  Usage  `json:"usage"`
-	Error
-}

relay/channel/anthropic/model.go

@@ -1,29 +0,0 @@
-package anthropic
-
-type Metadata struct {
-	UserId string `json:"user_id"`
-}
-
-type Request 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"`
-	//Metadata    `json:"metadata,omitempty"`
-	Stream bool `json:"stream,omitempty"`
-}
-
-type Error struct {
-	Type    string `json:"type"`
-	Message string `json:"message"`
-}
-
-type Response struct {
-	Completion string `json:"completion"`
-	StopReason string `json:"stop_reason"`
-	Model      string `json:"model"`
-	Error      Error  `json:"error"`
-}

relay/channel/baidu/model.go

@@ -1,50 +0,0 @@
-package baidu
-
-import (
-	"one-api/relay/channel/openai"
-	"time"
-)
-
-type ChatResponse 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            openai.Usage `json:"usage"`
-	BaiduError
-}
-
-type ChatStreamResponse struct {
-	ChatResponse
-	SentenceId int  `json:"sentence_id"`
-	IsEnd      bool `json:"is_end"`
-}
-
-type EmbeddingRequest struct {
-	Input []string `json:"input"`
-}
-
-type EmbeddingData struct {
-	Object    string    `json:"object"`
-	Embedding []float64 `json:"embedding"`
-	Index     int       `json:"index"`
-}
-
-type EmbeddingResponse struct {
-	Id      string          `json:"id"`
-	Object  string          `json:"object"`
-	Created int64           `json:"created"`
-	Data    []EmbeddingData `json:"data"`
-	Usage   openai.Usage    `json:"usage"`
-	BaiduError
-}
-
-type AccessToken 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:"-"`
-}

relay/channel/google/model.go

@@ -1,80 +0,0 @@
-package google
-
-import (
-	"one-api/relay/channel/openai"
-)
-
-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"`
-}
-
-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   []openai.Message  `json:"messages"`
-	Filters    []PaLMFilter      `json:"filters"`
-	Error      PaLMError         `json:"error"`
-}

relay/channel/openai/constant.go

@@ -1,6 +0,0 @@
-package openai
-
-const (
-	ContentTypeText     = "text"
-	ContentTypeImageURL = "image_url"
-)

relay/channel/openai/model.go

@@ -1,283 +0,0 @@
-package openai
-
-type Message struct {
-	Role    string  `json:"role"`
-	Content any     `json:"content"`
-	Name    *string `json:"name,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"`
-}
-
-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
-}
-
-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) 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 Error struct {
-	Message string `json:"message"`
-	Type    string `json:"type"`
-	Param   string `json:"param"`
-	Code    any    `json:"code"`
-}
-
-type ErrorWithStatusCode struct {
-	Error
-	StatusCode int `json:"status_code"`
-}
-
-type SlimTextResponse struct {
-	Choices []TextResponseChoice `json:"choices"`
-	Usage   `json:"usage"`
-	Error   Error `json:"error"`
-}
-
-type TextResponseChoice struct {
-	Index        int `json:"index"`
-	Message      `json:"message"`
-	FinishReason string `json:"finish_reason"`
-}
-
-type TextResponse struct {
-	Id      string               `json:"id"`
-	Model   string               `json:"model,omitempty"`
-	Object  string               `json:"object"`
-	Created int64                `json:"created"`
-	Choices []TextResponseChoice `json:"choices"`
-	Usage   `json:"usage"`
-}
-
-type EmbeddingResponseItem struct {
-	Object    string    `json:"object"`
-	Index     int       `json:"index"`
-	Embedding []float64 `json:"embedding"`
-}
-
-type EmbeddingResponse struct {
-	Object string                  `json:"object"`
-	Data   []EmbeddingResponseItem `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"`
-}

relay/channel/openai/util.go

@@ -1,13 +0,0 @@
-package openai
-
-func ErrorWrapper(err error, code string, statusCode int) *ErrorWithStatusCode {
-	Error := Error{
-		Message: err.Error(),
-		Type:    "one_api_error",
-		Code:    code,
-	}
-	return &ErrorWithStatusCode{
-		Error:      Error,
-		StatusCode: statusCode,
-	}
-}

relay/channel/tencent/model.go

@@ -1,63 +0,0 @@
-package tencent
-
-import (
-	"one-api/relay/channel/openai"
-)
-
-type Message struct {
-	Role    string `json:"role"`
-	Content string `json:"content"`
-}
-
-type ChatRequest 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 []Message `json:"messages"`
-}
-
-type Error struct {
-	Code    int    `json:"code"`
-	Message string `json:"message"`
-}
-
-type Usage struct {
-	InputTokens  int `json:"input_tokens"`
-	OutputTokens int `json:"output_tokens"`
-	TotalTokens  int `json:"total_tokens"`
-}
-
-type ResponseChoices struct {
-	FinishReason string  `json:"finish_reason,omitempty"` // 流式结束标志位，为 stop 则表示尾包
-	Messages     Message `json:"messages,omitempty"`      // 内容，同步模式返回内容，流模式为 null 输出 content 内容总数最多支持 1024token。
-	Delta        Message `json:"delta,omitempty"`         // 内容，流模式返回内容，同步模式为 null 输出 content 内容总数最多支持 1024token。
-}
-
-type ChatResponse struct {
-	Choices []ResponseChoices `json:"choices,omitempty"` // 结果
-	Created string            `json:"created,omitempty"` // unix 时间戳的字符串
-	Id      string            `json:"id,omitempty"`      // 会话 id
-	Usage   openai.Usage      `json:"usage,omitempty"`   // token 数量
-	Error   Error             `json:"error,omitempty"`   // 错误信息 注意：此字段可能返回 null，表示取不到有效值
-	Note    string            `json:"note,omitempty"`    // 注释
-	ReqID   string            `json:"req_id,omitempty"`  // 唯一请求 Id，每次请求都会返回。用于反馈接口入参
-}

relay/channel/xunfei/model.go

@@ -1,61 +0,0 @@
-package xunfei
-
-import (
-	"one-api/relay/channel/openai"
-)
-
-type Message struct {
-	Role    string `json:"role"`
-	Content string `json:"content"`
-}
-
-type ChatRequest 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 []Message `json:"text"`
-		} `json:"message"`
-	} `json:"payload"`
-}
-
-type ChatResponseTextItem struct {
-	Content string `json:"content"`
-	Role    string `json:"role"`
-	Index   int    `json:"index"`
-}
-
-type ChatResponse 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   []ChatResponseTextItem `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 openai.Usage `json:"text"`
-		} `json:"usage"`
-	} `json:"payload"`
-}

relay/channel/zhipu/model.go

@@ -1,46 +0,0 @@
-package zhipu
-
-import (
-	"one-api/relay/channel/openai"
-	"time"
-)
-
-type Message struct {
-	Role    string `json:"role"`
-	Content string `json:"content"`
-}
-
-type Request struct {
-	Prompt      []Message `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 ResponseData struct {
-	TaskId       string    `json:"task_id"`
-	RequestId    string    `json:"request_id"`
-	TaskStatus   string    `json:"task_status"`
-	Choices      []Message `json:"choices"`
-	openai.Usage `json:"usage"`
-}
-
-type Response struct {
-	Code    int          `json:"code"`
-	Msg     string       `json:"msg"`
-	Success bool         `json:"success"`
-	Data    ResponseData `json:"data"`
-}
-
-type StreamMetaResponse struct {
-	RequestId    string `json:"request_id"`
-	TaskId       string `json:"task_id"`
-	TaskStatus   string `json:"task_status"`
-	openai.Usage `json:"usage"`
-}
-
-type tokenData struct {
-	Token      string
-	ExpiryTime time.Time
-}

relay/constant/main.go

@@ -1,16 +0,0 @@
-package constant
-
-const (
-	RelayModeUnknown = iota
-	RelayModeChatCompletions
-	RelayModeCompletions
-	RelayModeEmbeddings
-	RelayModeModerations
-	RelayModeImagesGenerations
-	RelayModeEdits
-	RelayModeAudioSpeech
-	RelayModeAudioTranscription
-	RelayModeAudioTranslation
-)
-
-var StopFinishReason = "stop"

relay/util/common.go

@@ -1,166 +0,0 @@
-package util
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"one-api/common"
-	"one-api/model"
-	"one-api/relay/channel/openai"
-	"strconv"
-	"strings"
-
-	"github.com/gin-gonic/gin"
-)
-
-func ShouldDisableChannel(err *openai.Error, 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 *openai.Error) bool {
-	if !common.AutomaticEnableChannelEnabled {
-		return false
-	}
-	if err != nil {
-		return false
-	}
-	if openAIErr != nil {
-		return false
-	}
-	return true
-}
-
-type GeneralErrorResponse struct {
-	Error    openai.Error `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) (ErrorWithStatusCode *openai.ErrorWithStatusCode) {
-	ErrorWithStatusCode = &openai.ErrorWithStatusCode{
-		StatusCode: resp.StatusCode,
-		Error: openai.Error{
-			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
-		ErrorWithStatusCode.Error = errResponse.Error
-	} else {
-		ErrorWithStatusCode.Error.Message = errResponse.ToMessage()
-	}
-	if ErrorWithStatusCode.Error.Message == "" {
-		ErrorWithStatusCode.Error.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
-}

relay/util/init.go

@@ -1,24 +0,0 @@
-package util
-
-import (
-	"net/http"
-	"one-api/common"
-	"time"
-)
-
-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,
-	}
-}

web/berry/src/layout/MinimalLayout/index.js

@@ -26,7 +26,7 @@ const MinimalLayout = () => {
           <Header />
         </Toolbar>
       </AppBar>
-      <Box sx={{ flex: '1 1 auto', overflow: 'auto' }} marginTop={'80px'}>
+      <Box sx={{ flex: '1 1 auto', overflow: 'auto' }} paddingTop={'64px'}>
         <Outlet />
       </Box>
       <Box sx={{ flex: 'none' }}>

web/berry/src/ui-component/Logo.js

@@ -15,7 +15,7 @@ import { useSelector } from 'react-redux';
 const Logo = () => {
   const siteInfo = useSelector((state) => state.siteInfo);
 
-  return <img src={siteInfo.logo || logo} alt={siteInfo.system_name} height="50" />;
+  return <img src={siteInfo.logo || logo} alt={siteInfo.system_name} width="80" />;
 };
 
 export default Logo;

web/berry/src/views/Channel/component/EditModal.js

@@ -21,18 +21,12 @@ import {
   Container,
   Autocomplete,
   FormHelperText,
-  Checkbox
 } from "@mui/material";
 
 import { Formik } from "formik";
 import * as Yup from "yup";
 import { defaultConfig, typeConfig } from "../type/Config"; //typeConfig
 import { createFilterOptions } from "@mui/material/Autocomplete";
-import CheckBoxOutlineBlankIcon from '@mui/icons-material/CheckBoxOutlineBlank';
-import CheckBoxIcon from '@mui/icons-material/CheckBox';
-
-const icon = <CheckBoxOutlineBlankIcon fontSize="small" />;
-const checkedIcon = <CheckBoxIcon fontSize="small" />;
 
 const filter = createFilterOptions();
 const validationSchema = Yup.object().shape({
@@ -47,7 +41,7 @@ const validationSchema = Yup.object().shape({
   models: Yup.array().min(1, "模型 不能为空"),
   groups: Yup.array().min(1, "用户组 不能为空"),
   base_url: Yup.string().when("type", {
-    is: (value) => [3, 8].includes(value),
+    is: (value) => [3, 24, 8].includes(value),
     then: Yup.string().required("渠道API地址 不能为空"), // base_url 是必需的
     otherwise: Yup.string(), // 在其他情况下，base_url 可以是任意字符串
   }),
@@ -150,23 +144,8 @@ const EditModal = ({ open, channelId, onCancel, onOk }) => {
   const fetchModels = async () => {
     try {
       let res = await API.get(`/api/channel/models`);
-      const { data } = res.data;
-      data.forEach(item => {
-        if (!item.owned_by) {
-          item.owned_by = "未知";
-        }
-      });
-      // 先对data排序
-      data.sort((a, b) => {
-        const ownedByComparison = a.owned_by.localeCompare(b.owned_by);
-        if (ownedByComparison === 0) {
-          return a.id.localeCompare(b.id);
-        }
-        return ownedByComparison;
-      });
-
       setModelOptions(
-         data.map((model) => {
+        res.data.data.map((model) => {
           return {
             id: model.id,
             group: model.owned_by,
@@ -258,7 +237,6 @@ const EditModal = ({ open, channelId, onCancel, onOk }) => {
           2
         );
       }
-      data.base_url = data.base_url ?? '';
       data.is_edit = true;
       initChannel(data.type);
       setInitialInput(data);
@@ -270,16 +248,12 @@ const EditModal = ({ open, channelId, onCancel, onOk }) => {
   useEffect(() => {
     fetchGroups().then();
     fetchModels().then();
-  }, []);
-
-  useEffect(() => {
     if (channelId) {
       loadChannel().then();
     } else {
       initChannel(1);
       setInitialInput({ ...defaultConfig.input, is_edit: false });
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [channelId]);
 
   return (
@@ -515,8 +489,7 @@ const EditModal = ({ open, channelId, onCancel, onOk }) => {
                     handleChange(event);
                   }}
                   onBlur={handleBlur}
-                  // filterSelectedOptions
-                  disableCloseOnSelect
+                  filterSelectedOptions
                   renderInput={(params) => (
                     <TextField
                       {...params}
@@ -549,12 +522,6 @@ const EditModal = ({ open, channelId, onCancel, onOk }) => {
                     }
                     return filtered;
                   }}
-                  renderOption={(props, option, { selected }) => (
-                    <li {...props}>
-                      <Checkbox icon={icon} checkedIcon={checkedIcon} style={{ marginRight: 8 }} checked={selected} />
-                      {option.id}
-                    </li>
-                  )}
                 />
                 {errors.models ? (
                   <FormHelperText error id="helper-tex-channel-models-label">

web/berry/src/views/Token/component/TableRow.js

@@ -192,7 +192,7 @@ export default function TokensTableRow({ item, manageToken, handleOpenModal, set
               id={`switch-${item.id}`}
               checked={statusSwitch === 1}
               onChange={handleStatus}
-              // disabled={statusSwitch !== 1 && statusSwitch !== 2}
+              disabled={statusSwitch !== 1 && statusSwitch !== 2}
             />
           </Tooltip>
         </TableCell>

web/default/src/components/SystemSetting.js

@@ -16,6 +16,7 @@ const SystemSetting = () => {
     SMTPAccount: '',
     SMTPFrom: '',
     SMTPToken: '',
+    SMTPAuthLoginEnabled: '',
     ServerAddress: '',
     Footer: '',
     WeChatAuthEnabled: '',
@@ -72,6 +73,7 @@ const SystemSetting = () => {
       case 'TurnstileCheckEnabled':
       case 'EmailDomainRestrictionEnabled':
       case 'RegisterEnabled':
+      case 'SMTPAuthLoginEnabled':
         value = inputs[key] === 'true' ? 'false' : 'true';
         break;
       default:
@@ -103,7 +105,7 @@ const SystemSetting = () => {
     }
     if (
       name === 'Notice' ||
-      name.startsWith('SMTP') ||
+      (name.startsWith('SMTP') && !name.endsWith('Enabled')) ||
       name === 'ServerAddress' ||
       name === 'GitHubClientId' ||
       name === 'GitHubClientSecret' ||
@@ -411,6 +413,12 @@ const SystemSetting = () => {
               checked={inputs.RegisterEnabled === 'true'}
               placeholder='敏感信息不会发送到前端显示'
             />
+            <Form.Checkbox
+              checked={inputs.SMTPAuthLoginEnabled === 'true'}
+              label='使用 SMTP LOGIN 认证方式'
+              name='SMTPAuthLoginEnabled'
+              onChange={handleInputChange}
+            />
           </Form.Group>
           <Form.Button onClick={submitSMTP}>保存 SMTP 设置</Form.Button>
           <Divider />