feat: support aws claude

feat: 支持ollama embedding数组传参
feat: 启用函数计费
2025-11-18 11:33:42 +08:00 · 2024-04-23 11:44:40 +08:00 · 2024-04-22 21:09:11 +08:00 · 2024-04-22 16:35:56 +08:00 · 2024-04-21 12:51:08 +08:00 · 2024-04-20 21:05:38 +08:00
155 changed files with 12736 additions and 8989 deletions
--- a/.github/workflows/docker-image-amd64.yml
+++ b/.github/workflows/docker-image-amd64.yml
@@ -4,7 +4,6 @@ on:
  push:
    tags:
      - '*'
-      - '!*-alpha*'
  workflow_dispatch:
    inputs:
      name:
--- a/.github/workflows/docker-image-arm64.yml
+++ b/.github/workflows/docker-image-arm64.yml
@@ -4,7 +4,6 @@ on:
  push:
    tags:
      - '*'
-      - '!*-alpha*'
  workflow_dispatch:
    inputs:
      name:
--- a/4
+++ b/4
@@ -5,7 +5,7 @@ COPY web/package.json .
 RUN npm install
 COPY ./web .
 COPY ./VERSION .
-RUN DISABLE_ESLINT_PLUGIN='true' REACT_APP_VERSION=$(cat VERSION) npm run build
+RUN DISABLE_ESLINT_PLUGIN='true' VITE_REACT_APP_VERSION=$(cat VERSION) npm run build

 FROM golang AS builder2

@@ -17,7 +17,7 @@ WORKDIR /build
 ADD go.mod go.sum ./
 RUN go mod download
 COPY . .
-COPY --from=builder /build/build ./web/build
+COPY --from=builder /build/dist ./web/dist
 RUN go build -ldflags "-s -w -X 'one-api/common.Version=$(cat VERSION)' -extldflags '-static'" -o one-api

 FROM alpine
--- a/Midjourney.md
+++ b/Midjourney.md
@@ -2,290 +2,66 @@

 **简介**:Midjourney Proxy API文档

-## 模型价格设置（在设置-运营设置-模型固定价格设置中设置）
+## 模型列表

+### midjourney-proxy支持
+
+- mj_imagine (绘图)
+- mj_variation (变换)
+- mj_reroll (重绘)
+- mj_blend (混合)
+- mj_upscale (放大)
+- mj_describe (图生文)
+
+### 仅midjourney-proxy-plus支持
+
+- mj_zoom (比例变焦)
+- mj_shorten (提示词缩短)
+- mj_modal (窗口提交，局部重绘和自定义比例变焦必须和mj_modal一同添加)
+- mj_inpaint (局部重绘提交，必须和mj_modal一同添加)
+- mj_custom_zoom (自定义比例变焦，必须和mj_modal一同添加)
+- mj_high_variation (强变换)
+- mj_low_variation (弱变换)
+- mj_pan (平移)
+- swap_face (换脸)
+
+## 模型价格设置（在设置-运营设置-模型固定价格设置中设置）
 ```json
 {
-  "gpt-4-gizmo-*": 0.1,
  "mj_imagine": 0.1,
  "mj_variation": 0.1,
  "mj_reroll": 0.1,
  "mj_blend": 0.1,
+  "mj_modal": 0.1,
+  "mj_zoom": 0.1,
+  "mj_shorten": 0.1,
+  "mj_high_variation": 0.1,
+  "mj_low_variation": 0.1,
+  "mj_pan": 0.1,
+  "mj_inpaint": 0,
+  "mj_custom_zoom": 0,
  "mj_describe": 0.05,
-  "mj_upscale": 0.05
+  "mj_upscale": 0.05,
+  "swap_face": 0.05
 }
 ```
+其中mj_inpaint和mj_custom_zoom的价格设置为0，是因为这两个模型需要搭配mj_modal使用，所以价格由mj_modal决定。

 ## 渠道设置

-### 对接 midjourney-proxy
-1. 部署Midjourney-Proxy，并配置好midjourney账号等（强烈建议设置密钥），[项目地址](https://github.com/novicezk/midjourney-proxy)
-2. 在渠道管理中添加渠道，渠道类型选择Midjourney Proxy，模型选择midjourney
+### 对接 midjourney-proxy(plus)
+
+1.
+
+部署Midjourney-Proxy，并配置好midjourney账号等（强烈建议设置密钥），[项目地址](https://github.com/novicezk/midjourney-proxy)
+
+2. 在渠道管理中添加渠道，渠道类型选择**Midjourney Proxy**，如果是plus版本选择**Midjourney Proxy Plus**
+   ，模型请参考上方模型列表
 3. 地址填写midjourney-proxy部署的地址，例如：http://localhost:8080
 4. 密钥填写midjourney-proxy的密钥，如果没有设置密钥，可以随便填

 ### 对接上游new api
-1. 在渠道管理中添加渠道，渠道类型选择Midjourney Proxy，模型选择midjourney
-2. 地址填写上游new api的地址，例如：http://localhost:8080
-3. 密钥填写上游new api的密钥

-## 任务提交
-
-### 绘图变化
-
-**接口地址**:`/mj/submit/change`
-
-**请求方式**:`POST`
-
-**请求数据类型**:`application/json`
-
-**响应数据类型**:`*/*`
-
-**接口描述**:
-
-**请求示例**:
-
-```javascript
-{
-    "action"
-:
-    "UPSCALE",
-        "index"
-:
-    1,
-        "notifyHook"
-:
-    "",
-        "state"
-:
-    "",
-        "taskId"
-:
-    "1320098173412546"
-}
-```
-
-**请求参数**:
-
-| 参数名称                   | 参数说明                                                                  | 请求类型 | 是否必须  | 数据类型           | schema   |
-|------------------------|-----------------------------------------------------------------------|------|-------|----------------|----------|
-| changeDTO              | changeDTO                                                             | body | true  | 变化任务提交参数       | 变化任务提交参数 |
-| &emsp;&emsp;action     | UPSCALE(放大); VARIATION(变换); REROLL(重新生成),可用值:UPSCALE,VARIATION,REROLL |      | true  | string         |          |
-| &emsp;&emsp;index      | 序号(1~4), action为UPSCALE,VARIATION时必传                                  |      | false | integer(int32) |          |
-| &emsp;&emsp;notifyHook | 回调地址, 为空时使用全局notifyHook                                               |      | false | string         |          |
-| &emsp;&emsp;state      | 自定义参数                                                                 |      | false | string         |          |
-| &emsp;&emsp;taskId     | 任务ID                                                                  |      | true  | string         |          |
-
-**响应状态**:
-
-| 状态码 | 说明           | schema |
-|-----|--------------|--------| 
-| 200 | OK           | 提交结果   |
-| 201 | Created      |        |
-| 401 | Unauthorized |        |
-| 403 | Forbidden    |        |
-| 404 | Not Found    |        |
-
-**响应参数**:
-
-| 参数名称        | 参数说明                                      | 类型             | schema         |
-|-------------|-------------------------------------------|----------------|----------------| 
-| code        | 状态码: 1(提交成功), 21(已存在), 22(排队中), other(错误) | integer(int32) | integer(int32) |
-| description | 描述                                        | string         |                |
-| properties  | 扩展字段                                      | object         |                |
-| result      | 任务ID                                      | string         |                |
-
-**响应示例**:
-
-```javascript
-{
-    "code"
-:
-    1,
-        "description"
-:
-    "提交成功",
-        "properties"
-:
-    {
-    }
-,
-    "result"
-:
-    1320098173412546
-}
-```
-
-### 提交Imagine任务
-
-**接口地址**:`/mj/submit/imagine`
-
-**请求方式**:`POST`
-
-**请求数据类型**:`application/json`
-
-**响应数据类型**:`*/*`
-
-**接口描述**:
-
-**请求示例**:
-
-```javascript
-{
-    "base64"
-:
-    "",
-        "notifyHook"
-:
-    "",
-        "prompt"
-:
-    "Cat",
-        "state"
-:
-    ""
-}
-```
-
-**请求参数**:
-
-| 参数名称                   | 参数说明                    | 请求类型 | 是否必须  | 数据类型        | schema      |
-|------------------------|-------------------------|------|-------|-------------|-------------|
-| imagineDTO             | imagineDTO              | body | true  | Imagine提交参数 | Imagine提交参数 |
-| &emsp;&emsp;base64     | 垫图base64                |      | false | string      |             |
-| &emsp;&emsp;notifyHook | 回调地址, 为空时使用全局notifyHook |      | false | string      |             |
-| &emsp;&emsp;prompt     | 提示词                     |      | true  | string      |             |
-| &emsp;&emsp;state      | 自定义参数                   |      | false | string      |             |
-
-**响应状态**:
-
-| 状态码 | 说明           | schema |
-|-----|--------------|--------| 
-| 200 | OK           | 提交结果   |
-| 201 | Created      |        |
-| 401 | Unauthorized |        |
-| 403 | Forbidden    |        |
-| 404 | Not Found    |        |
-
-**响应参数**:
-
-| 参数名称        | 参数说明                                      | 类型             | schema         |
-|-------------|-------------------------------------------|----------------|----------------| 
-| code        | 状态码: 1(提交成功), 21(已存在), 22(排队中), other(错误) | integer(int32) | integer(int32) |
-| description | 描述                                        | string         |                |
-| properties  | 扩展字段                                      | object         |                |
-| result      | 任务ID                                      | string         |                |
-
-**响应示例**:
-
-```javascript
-{
-    "code"
-:
-    1,
-        "description"
-:
-    "提交成功",
-        "properties"
-:
-    {
-    }
-,
-    "result"
-:
-    1320098173412546
-}
-```
-
-## 任务查询
-
-### 指定ID获取任务
-
-**接口地址**:`/mj/task/{id}/fetch`
-
-**请求方式**:`GET`
-
-**请求数据类型**:`application/x-www-form-urlencoded`
-
-**响应数据类型**:`*/*`
-
-**接口描述**:
-
-**请求参数**:
-
-| 参数名称 | 参数说明 | 请求类型 | 是否必须  | 数据类型   | schema |
-|------|------|------|-------|--------|--------|
-| id   | 任务ID | path | false | string |        |
-
-**响应状态**:
-
-| 状态码 | 说明           | schema |
-|-----|--------------|--------| 
-| 200 | OK           | 任务     |
-| 401 | Unauthorized |        |
-| 403 | Forbidden    |        |
-| 404 | Not Found    |        |
-
-**响应参数**:
-
-| 参数名称        | 参数说明                                                     | 类型             | schema         |
-|-------------|----------------------------------------------------------|----------------|----------------| 
-| action      | 可用值:IMAGINE,UPSCALE,VARIATION,REROLL,DESCRIBE,BLEND      | string         |                |
-| description | 任务描述                                                     | string         |                |
-| failReason  | 失败原因                                                     | string         |                |
-| finishTime  | 结束时间                                                     | integer(int64) | integer(int64) |
-| id          | 任务ID                                                     | string         |                |
-| imageUrl    | 图片url                                                    | string         |                |
-| progress    | 任务进度                                                     | string         |                |
-| prompt      | 提示词                                                      | string         |                |
-| promptEn    | 提示词-英文                                                   | string         |                |
-| startTime   | 开始执行时间                                                   | integer(int64) | integer(int64) |
-| state       | 自定义参数                                                    | string         |                |
-| status      | 任务状态,可用值:NOT_START,SUBMITTED,IN_PROGRESS,FAILURE,SUCCESS | string         |                |
-| submitTime  | 提交时间                                                     | integer(int64) | integer(int64) |
-
-**响应示例**:
-
-```javascript
-{
-    "action"
-:
-    "",
-        "description"
-:
-    "",
-        "failReason"
-:
-    "",
-        "finishTime"
-:
-    0,
-        "id"
-:
-    "",
-        "imageUrl"
-:
-    "",
-        "progress"
-:
-    "",
-        "prompt"
-:
-    "",
-        "promptEn"
-:
-    "",
-        "startTime"
-:
-    0,
-        "state"
-:
-    "",
-        "status"
-:
-    "",
-        "submitTime"
-:
-    0
-}
-```
+1. 在渠道管理中添加渠道，渠道类型选择**Midjourney Proxy Plus**，模型请参考上方模型列表
+2. 地址填写上游new api的地址，例如：http://localhost:3000
+3. 密钥填写上游new api的密钥
--- a/README.md
+++ b/README.md
@@ -18,7 +18,7 @@
 此分叉版本的主要变更如下：

 1. 全新的UI界面（部分界面还待更新）
-2. 添加[Midjourney-Proxy](https://github.com/novicezk/midjourney-proxy)接口的支持
+2. 添加[Midjourney-Proxy(Plus)](https://github.com/novicezk/midjourney-proxy)接口的支持，[对接文档](Midjourney.md)，支持的接口如下：
   + [x] /mj/submit/imagine
   + [x] /mj/submit/change
   + [x] /mj/submit/blend
@@ -26,6 +26,11 @@
   + [x] /mj/image/{id} （通过此接口获取图片，**请必须在系统设置中填写服务器地址！！**）
   + [x] /mj/task/{id}/fetch （此接口返回的图片地址为经过One API转发的地址）
   + [x] /task/list-by-condition
+   + [x] /mj/submit/action （仅midjourney-proxy-plus支持，下同）
+   + [x] /mj/submit/modal
+   + [x] /mj/submit/shorten
+   + [x] /mj/task/{id}/image-seed
+   + [x] /mj/insight-face/swap （InsightFace）
 3. 支持在线充值功能，可在系统设置中设置，当前支持的支付接口：
   + [x] 易支付
 4. 支持用key查询使用额度:
@@ -37,16 +42,33 @@
 9. 支持渠道**加权随机**
 10. 数据看板
 11. 可设置令牌能调用的模型
-12. 支持Telegram授权登录
+12. 支持Telegram授权登录。
+    1. 系统设置-配置登录注册-允许通过Telegram登录
+    2. 对[@Botfather](https://t.me/botfather)输入指令/setdomain
+    3. 选择你的bot，然后输入http(s)://你的网站地址/login
+    4. Telegram Bot 名称是bot username 去掉@后的字符串

 ## 模型支持
 此版本额外支持以下模型：
 1. 第三方模型 **gps** （gpt-4-gizmo-*）
 2. 智谱glm-4v，glm-4v识图
 3. Anthropic Claude 3 (claude-3-opus-20240229, claude-3-sonnet-20240229)
+4. [Ollama](https://github.com/ollama/ollama?tab=readme-ov-file)，添加渠道时，密钥可以随便填写，默认的请求地址是[http://localhost:11434](http://localhost:11434)，如果需要修改请在渠道中修改
+5. [Midjourney-Proxy(Plus)](https://github.com/novicezk/midjourney-proxy)接口，[对接文档](Midjourney.md)
+6. [零一万物](https://platform.lingyiwanwu.com/)

 您可以在渠道中添加自定义模型gpt-4-gizmo-*，此模型并非OpenAI官方模型，而是第三方模型，使用官方key无法调用。

+## 渠道重试
+渠道重试功能已经实现，可以在`设置->运营设置->通用设置`设置重试次数，建议开启缓存功能。  
+如果开启了重试功能，第一次重试使用同优先级，第二次重试使用下一个优先级，以此类推。  
+### 缓存设置方法
+1. `REDIS_CONN_STRING`：设置之后将使用 Redis 作为缓存使用。
+    + 例子：`REDIS_CONN_STRING=redis://default:redispw@localhost:49153`
+2. `MEMORY_CACHE_ENABLED`：启用内存缓存（如果设置了`REDIS_CONN_STRING`，则无需手动设置），会导致用户额度的更新存在一定的延迟，可选值为 `true` 和 `false`，未设置则默认为 `false`。
+    + 例子：`MEMORY_CACHE_ENABLED=true`
+
+
 ## 部署
 ### 基于 Docker 进行部署
 ```shell
@@ -87,6 +109,12 @@ docker run --name new-api -d --restart always -p 3000:3000 -e SQL_DSN="root:1234
 ![image](https://github.com/Calcium-Ion/new-api/assets/61247483/5b3228e8-2556-44f7-97d6-4f8d8ee6effa)  
 ![image](https://github.com/Calcium-Ion/new-api/assets/61247483/af9a07ee-5101-4b3d-8bd9-ae21a4fd7e9e)

+## 相关项目
+- [One API](https://github.com/songquanpeng/one-api)：原版项目
+- [Midjourney-Proxy](https://github.com/novicezk/midjourney-proxy)：Midjourney接口支持
+- [chatnio](https://github.com/Deeptrain-Community/chatnio)：下一代 AI 一站式 B/C 端解决方案
+- [neko-api-key-tool](https://github.com/Calcium-Ion/neko-api-key-tool)：用key查询使用额度
+
 ## Star History

 [![Star History Chart](https://api.star-history.com/svg?repos=Calcium-Ion/new-api&type=Date)](https://star-history.com/#Calcium-Ion/new-api&Date)
--- a/common/constants.go
+++ b/common/constants.go
@@ -9,15 +9,6 @@ import (
 	"github.com/google/uuid"
 )

-// Pay Settings
-
-var PayAddress = ""
-var CustomCallbackAddress = ""
-var EpayId = ""
-var EpayKey = ""
-var Price = 7.3
-var MinTopUp = 1
-
 var StartTime = time.Now().Unix() // unit: second
 var Version = "v0.0.0"            // this hard coding will be replaced automatically when building, no need to manually change
 var SystemName = "New API"
@@ -55,7 +46,8 @@ var TelegramOAuthEnabled = false
 var TurnstileCheckEnabled = false
 var RegisterEnabled = true

-var EmailDomainRestrictionEnabled = false
+var EmailDomainRestrictionEnabled = false // 是否启用邮箱域名限制
+var EmailAliasRestrictionEnabled = false  // 是否启用邮箱别名限制
 var EmailDomainWhitelist = []string{
 	"gmail.com",
 	"163.com",
@@ -75,6 +67,7 @@ var LogConsumeEnabled = true

 var SMTPServer = ""
 var SMTPPort = 587
+var SMTPSSLEnabled = false
 var SMTPAccount = ""
 var SMTPFrom = ""
 var SMTPToken = ""
@@ -110,7 +103,7 @@ var IsMasterNode = os.Getenv("NODE_TYPE") != "slave"
 var requestInterval, _ = strconv.Atoi(os.Getenv("POLLING_INTERVAL"))
 var RequestInterval = time.Duration(requestInterval) * time.Second

-var SyncFrequency = GetOrDefault("SYNC_FREQUENCY", 10*60) // unit is second
+var SyncFrequency = GetOrDefault("SYNC_FREQUENCY", 60) // unit is second

 var BatchUpdateEnabled = false
 var BatchUpdateInterval = GetOrDefault("BATCH_UPDATE_INTERVAL", 5)
@@ -188,8 +181,8 @@ const (
 	ChannelTypeOpenAI         = 1
 	ChannelTypeMidjourney     = 2
 	ChannelTypeAzure          = 3
-	ChannelTypeCloseAI        = 4
-	ChannelTypeOpenAISB       = 5
+	ChannelTypeOllama         = 4
+	ChannelTypeMidjourneyPlus = 5
 	ChannelTypeOpenAIMax      = 6
 	ChannelTypeOhMyGPT        = 7
 	ChannelTypeCustom         = 8
@@ -211,6 +204,9 @@ const (
 	ChannelTypeGemini         = 24
 	ChannelTypeMoonshot       = 25
 	ChannelTypeZhipu_v4       = 26
+	ChannelTypePerplexity     = 27
+	ChannelTypeLingYiWanWu    = 31
+	ChannelTypeAws            = 33
 )

 var ChannelBaseURLs = []string{
@@ -218,7 +214,7 @@ var ChannelBaseURLs = []string{
 	"https://api.openai.com",            // 1
 	"https://oa.api2d.net",              // 2
 	"",                                  // 3
-	"https://api.closeai-proxy.xyz",     // 4
+	"http://localhost:11434",            // 4
 	"https://api.openai-sb.com",         // 5
 	"https://api.openaimax.com",         // 6
 	"https://api.ohmygpt.com",           // 7
@@ -241,4 +237,12 @@ var ChannelBaseURLs = []string{
 	"https://generativelanguage.googleapis.com", //24
 	"https://api.moonshot.cn",                   //25
 	"https://open.bigmodel.cn",                  //26
+	"https://api.perplexity.ai",                 //27
+	"",                                          //28
+	"",                                          //29
+	"",                                          //30
+	"https://api.lingyiwanwu.com",               //31
+	"",                                          //32
+	"",                                          //33
+
 }
--- a/common/database.go
+++ b/common/database.go
@@ -2,5 +2,6 @@ package common

 var UsingSQLite = false
 var UsingPostgreSQL = false
+var UsingMySQL = false

 var SQLitePath = "one-api.db?_busy_timeout=5000"
--- a/common/email.go
+++ b/common/email.go
@@ -24,7 +24,7 @@ func SendEmail(subject string, receiver string, content string) error {
 	addr := fmt.Sprintf("%s:%d", SMTPServer, SMTPPort)
 	to := strings.Split(receiver, ";")
 	var err error
-	if SMTPPort == 465 {
+	if SMTPPort == 465 || SMTPSSLEnabled {
 		tlsConfig := &tls.Config{
 			InsecureSkipVerify: true,
 			ServerName:         SMTPServer,
--- a/common/gin.go
+++ b/common/gin.go
@@ -5,18 +5,37 @@ import (
 	"encoding/json"
 	"github.com/gin-gonic/gin"
 	"io"
+	"strings"
 )

-func UnmarshalBodyReusable(c *gin.Context, v any) error {
+const KeyRequestBody = "key_request_body"
+
+func GetRequestBody(c *gin.Context) ([]byte, error) {
+	requestBody, _ := c.Get(KeyRequestBody)
+	if requestBody != nil {
+		return requestBody.([]byte), nil
+	}
 	requestBody, err := io.ReadAll(c.Request.Body)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	err = c.Request.Body.Close()
+	_ = c.Request.Body.Close()
+	c.Set(KeyRequestBody, requestBody)
+	return requestBody.([]byte), nil
+}
+
+func UnmarshalBodyReusable(c *gin.Context, v any) error {
+	requestBody, err := GetRequestBody(c)
 	if err != nil {
 		return err
 	}
-	err = json.Unmarshal(requestBody, &v)
+	contentType := c.Request.Header.Get("Content-Type")
+	if strings.HasPrefix(contentType, "application/json") {
+		err = json.Unmarshal(requestBody, &v)
+	} else {
+		// skip for now
+		// TODO: someday non json request have variant model, we will need to implementation this
+	}
 	if err != nil {
 		return err
 	}
--- a/common/image.go
+++ b/common/image.go
@@ -5,7 +5,7 @@ import (
 	"encoding/base64"
 	"errors"
 	"fmt"
-	"github.com/chai2010/webp"
+	"golang.org/x/image/webp"
 	"image"
 	"io"
 	"net/http"
--- a/common/model-ratio.go
+++ b/common/model-ratio.go
@@ -3,109 +3,137 @@ package common
 import (
 	"encoding/json"
 	"strings"
-	"time"
 )

-// ModelRatio
+// modelRatio
 // https://platform.openai.com/docs/models/model-endpoint-compatibility
 // https://cloud.baidu.com/doc/WENXINWORKSHOP/s/Blfmc9dlf
 // https://openai.com/pricing
 // TODO: when a new api is enabled, check the pricing here
 // 1 === $0.002 / 1K tokens
 // 1 === ￥0.014 / 1k tokens
-var ModelRatio = map[string]float64{
+
+var DefaultModelRatio = map[string]float64{
 	//"midjourney":                50,
-	"gpt-4-gizmo-*":             15,
-	"gpt-4":                     15,
-	"gpt-4-0314":                15,
-	"gpt-4-0613":                15,
-	"gpt-4-32k":                 30,
-	"gpt-4-32k-0314":            30,
+	"gpt-4-gizmo-*": 15,
+	"gpt-4":         15,
+	//"gpt-4-0314":                   15, //deprecated
+	"gpt-4-0613": 15,
+	"gpt-4-32k":  30,
+	//"gpt-4-32k-0314":               30, //deprecated
 	"gpt-4-32k-0613":            30,
 	"gpt-4-1106-preview":        5,    // $0.01 / 1K tokens
 	"gpt-4-0125-preview":        5,    // $0.01 / 1K tokens
 	"gpt-4-turbo-preview":       5,    // $0.01 / 1K tokens
 	"gpt-4-vision-preview":      5,    // $0.01 / 1K tokens
 	"gpt-4-1106-vision-preview": 5,    // $0.01 / 1K tokens
-	"gpt-3.5-turbo":             0.75, // $0.0015 / 1K tokens
-	"gpt-3.5-turbo-0301":        0.75,
-	"gpt-3.5-turbo-0613":        0.75,
-	"gpt-3.5-turbo-16k":         1.5, // $0.003 / 1K tokens
-	"gpt-3.5-turbo-16k-0613":    1.5,
-	"gpt-3.5-turbo-instruct":    0.75, // $0.0015 / 1K tokens
-	"gpt-3.5-turbo-1106":        0.5,  // $0.001 / 1K tokens
-	"gpt-3.5-turbo-0125":        0.25,
-	"babbage-002":               0.2, // $0.0004 / 1K tokens
-	"davinci-002":               1,   // $0.002 / 1K tokens
-	"text-ada-001":              0.2,
-	"text-babbage-001":          0.25,
-	"text-curie-001":            1,
-	"text-davinci-002":          10,
-	"text-davinci-003":          10,
-	"text-davinci-edit-001":     10,
-	"code-davinci-edit-001":     10,
-	"whisper-1":                 15,  // $0.006 / minute -> $0.006 / 150 words -> $0.006 / 200 tokens -> $0.03 / 1k tokens
-	"tts-1":                     7.5, // 1k characters -> $0.015
-	"tts-1-1106":                7.5, // 1k characters -> $0.015
-	"tts-1-hd":                  15,  // 1k characters -> $0.03
-	"tts-1-hd-1106":             15,  // 1k characters -> $0.03
-	"davinci":                   10,
-	"curie":                     10,
-	"babbage":                   10,
-	"ada":                       10,
-	"text-embedding-3-small":    0.01,
-	"text-embedding-3-large":    0.065,
-	"text-embedding-ada-002":    0.05,
-	"text-search-ada-doc-001":   10,
-	"text-moderation-stable":    0.1,
-	"text-moderation-latest":    0.1,
-	"dall-e-2":                  8,
-	"dall-e-3":                  16,
-	"claude-instant-1":          0.4,    // $0.8 / 1M tokens
-	"claude-2.0":                4,      // $8 / 1M tokens
-	"claude-2.1":                4,      // $8 / 1M tokens
-	"claude-3-sonnet-20240229":  1.5,    // $3 / 1M tokens
-	"claude-3-opus-20240229":    7.5,    // $15 / 1M tokens
-	"ERNIE-Bot":                 0.8572, // ￥0.012 / 1k tokens
-	"ERNIE-Bot-turbo":           0.5715, // ￥0.008 / 1k tokens
-	"ERNIE-Bot-4":               8.572,  // ￥0.12 / 1k tokens
-	"Embedding-V1":              0.1429, // ￥0.002 / 1k tokens
-	"PaLM-2":                    1,
-	"gemini-pro":                1,      // $0.00025 / 1k characters -> $0.001 / 1k tokens
-	"gemini-pro-vision":         1,      // $0.00025 / 1k characters -> $0.001 / 1k tokens
-	"chatglm_turbo":             0.3572, // ￥0.005 / 1k tokens
-	"chatglm_pro":               0.7143, // ￥0.01 / 1k tokens
-	"chatglm_std":               0.3572, // ￥0.005 / 1k tokens
-	"chatglm_lite":              0.1429, // ￥0.002 / 1k tokens
-	"glm-4":                     7.143,  // ￥0.1 / 1k tokens
-	"glm-4v":                    7.143,  // ￥0.1 / 1k tokens
-	"glm-3-turbo":               0.3572,
-	"qwen-turbo":                0.8572, // ￥0.012 / 1k tokens
-	"qwen-plus":                 10,     // ￥0.14 / 1k tokens
-	"text-embedding-v1":         0.05,   // ￥0.0007 / 1k tokens
-	"SparkDesk-v1.1":            1.2858, // ￥0.018 / 1k tokens
-	"SparkDesk-v2.1":            1.2858, // ￥0.018 / 1k tokens
-	"SparkDesk-v3.1":            1.2858, // ￥0.018 / 1k tokens
-	"SparkDesk-v3.5":            1.2858, // ￥0.018 / 1k tokens
-	"360GPT_S2_V9":              0.8572, // ¥0.012 / 1k tokens
-	"embedding-bert-512-v1":     0.0715, // ¥0.001 / 1k tokens
-	"embedding_s1_v1":           0.0715, // ¥0.001 / 1k tokens
-	"semantic_similarity_s1_v1": 0.0715, // ¥0.001 / 1k tokens
-	"hunyuan":                   7.143,  // ¥0.1 / 1k tokens  // https://cloud.tencent.com/document/product/1729/97731#e0e6be58-60c8-469f-bdeb-6c264ce3b4d0
+	"gpt-4-turbo":               5,    // $0.01 / 1K tokens
+	"gpt-3.5-turbo":             0.25, // $0.0015 / 1K tokens
+	//"gpt-3.5-turbo-0301":           0.75, //deprecated
+	"gpt-3.5-turbo-0613":           0.75,
+	"gpt-3.5-turbo-16k":            1.5, // $0.003 / 1K tokens
+	"gpt-3.5-turbo-16k-0613":       1.5,
+	"gpt-3.5-turbo-instruct":       0.75, // $0.0015 / 1K tokens
+	"gpt-3.5-turbo-1106":           0.5,  // $0.001 / 1K tokens
+	"gpt-3.5-turbo-0125":           0.25,
+	"babbage-002":                  0.2, // $0.0004 / 1K tokens
+	"davinci-002":                  1,   // $0.002 / 1K tokens
+	"text-ada-001":                 0.2,
+	"text-babbage-001":             0.25,
+	"text-curie-001":               1,
+	"text-davinci-002":             10,
+	"text-davinci-003":             10,
+	"text-davinci-edit-001":        10,
+	"code-davinci-edit-001":        10,
+	"whisper-1":                    15,  // $0.006 / minute -> $0.006 / 150 words -> $0.006 / 200 tokens -> $0.03 / 1k tokens
+	"tts-1":                        7.5, // 1k characters -> $0.015
+	"tts-1-1106":                   7.5, // 1k characters -> $0.015
+	"tts-1-hd":                     15,  // 1k characters -> $0.03
+	"tts-1-hd-1106":                15,  // 1k characters -> $0.03
+	"davinci":                      10,
+	"curie":                        10,
+	"babbage":                      10,
+	"ada":                          10,
+	"text-embedding-3-small":       0.01,
+	"text-embedding-3-large":       0.065,
+	"text-embedding-ada-002":       0.05,
+	"text-search-ada-doc-001":      10,
+	"text-moderation-stable":       0.1,
+	"text-moderation-latest":       0.1,
+	"dall-e-2":                     8,
+	"dall-e-3":                     16,
+	"claude-instant-1":             0.4,    // $0.8 / 1M tokens
+	"claude-2.0":                   4,      // $8 / 1M tokens
+	"claude-2.1":                   4,      // $8 / 1M tokens
+	"claude-3-haiku-20240307":      0.125,  // $0.25 / 1M tokens
+	"claude-3-sonnet-20240229":     1.5,    // $3 / 1M tokens
+	"claude-3-opus-20240229":       7.5,    // $15 / 1M tokens
+	"ERNIE-Bot":                    0.8572, // ￥0.012 / 1k tokens
+	"ERNIE-Bot-turbo":              0.5715, // ￥0.008 / 1k tokens
+	"ERNIE-Bot-4":                  8.572,  // ￥0.12 / 1k tokens
+	"Embedding-V1":                 0.1429, // ￥0.002 / 1k tokens
+	"PaLM-2":                       1,
+	"gemini-pro":                   1, // $0.00025 / 1k characters -> $0.001 / 1k tokens
+	"gemini-pro-vision":            1, // $0.00025 / 1k characters -> $0.001 / 1k tokens
+	"gemini-1.0-pro-vision-001":    1,
+	"gemini-1.0-pro-001":           1,
+	"gemini-1.5-pro-latest":        1,
+	"gemini-1.0-pro-latest":        1,
+	"gemini-1.0-pro-vision-latest": 1,
+	"gemini-ultra":                 1,
+	"chatglm_turbo":                0.3572, // ￥0.005 / 1k tokens
+	"chatglm_pro":                  0.7143, // ￥0.01 / 1k tokens
+	"chatglm_std":                  0.3572, // ￥0.005 / 1k tokens
+	"chatglm_lite":                 0.1429, // ￥0.002 / 1k tokens
+	"glm-4":                        7.143,  // ￥0.1 / 1k tokens
+	"glm-4v":                       7.143,  // ￥0.1 / 1k tokens
+	"glm-3-turbo":                  0.3572,
+	"qwen-turbo":                   0.8572, // ￥0.012 / 1k tokens
+	"qwen-plus":                    10,     // ￥0.14 / 1k tokens
+	"text-embedding-v1":            0.05,   // ￥0.0007 / 1k tokens
+	"SparkDesk-v1.1":               1.2858, // ￥0.018 / 1k tokens
+	"SparkDesk-v2.1":               1.2858, // ￥0.018 / 1k tokens
+	"SparkDesk-v3.1":               1.2858, // ￥0.018 / 1k tokens
+	"SparkDesk-v3.5":               1.2858, // ￥0.018 / 1k tokens
+	"360GPT_S2_V9":                 0.8572, // ¥0.012 / 1k tokens
+	"embedding-bert-512-v1":        0.0715, // ¥0.001 / 1k tokens
+	"embedding_s1_v1":              0.0715, // ¥0.001 / 1k tokens
+	"semantic_similarity_s1_v1":    0.0715, // ¥0.001 / 1k tokens
+	"hunyuan":                      7.143,  // ¥0.1 / 1k tokens  // https://cloud.tencent.com/document/product/1729/97731#e0e6be58-60c8-469f-bdeb-6c264ce3b4d0
+	// https://platform.lingyiwanwu.com/docs#-计费单元
+	// 已经按照 7.2 来换算美元价格
+	"yi-34b-chat-0205": 0.018,
+	"yi-34b-chat-200k": 0.0864,
+	"yi-vl-plus":       0.0432,
 }

-var ModelPrice = map[string]float64{
-	"gpt-4-gizmo-*": 0.1,
-	"mj_imagine":    0.1,
-	"mj_variation":  0.1,
-	"mj_reroll":     0.1,
-	"mj_blend":      0.1,
-	"mj_describe":   0.05,
-	"mj_upscale":    0.05,
+var DefaultModelPrice = map[string]float64{
+	"gpt-4-gizmo-*":     0.1,
+	"mj_imagine":        0.1,
+	"mj_variation":      0.1,
+	"mj_reroll":         0.1,
+	"mj_blend":          0.1,
+	"mj_modal":          0.1,
+	"mj_zoom":           0.1,
+	"mj_shorten":        0.1,
+	"mj_high_variation": 0.1,
+	"mj_low_variation":  0.1,
+	"mj_pan":            0.1,
+	"mj_inpaint":        0,
+	"mj_custom_zoom":    0,
+	"mj_describe":       0.05,
+	"mj_upscale":        0.05,
+	"swap_face":         0.05,
 }

+var modelPrice map[string]float64 = nil
+var modelRatio map[string]float64 = nil
+
 func ModelPrice2JSONString() string {
-	jsonBytes, err := json.Marshal(ModelPrice)
+	if modelPrice == nil {
+		modelPrice = DefaultModelPrice
+	}
+	jsonBytes, err := json.Marshal(modelPrice)
 	if err != nil {
 		SysError("error marshalling model price: " + err.Error())
 	}
@@ -113,15 +141,18 @@ func ModelPrice2JSONString() string {
 }

 func UpdateModelPriceByJSONString(jsonStr string) error {
-	ModelPrice = make(map[string]float64)
-	return json.Unmarshal([]byte(jsonStr), &ModelPrice)
+	modelPrice = make(map[string]float64)
+	return json.Unmarshal([]byte(jsonStr), &modelPrice)
 }

 func GetModelPrice(name string, printErr bool) float64 {
+	if modelPrice == nil {
+		modelPrice = DefaultModelPrice
+	}
 	if strings.HasPrefix(name, "gpt-4-gizmo") {
 		name = "gpt-4-gizmo-*"
 	}
-	price, ok := ModelPrice[name]
+	price, ok := modelPrice[name]
 	if !ok {
 		if printErr {
 			SysError("model price not found: " + name)
@@ -132,7 +163,10 @@ func GetModelPrice(name string, printErr bool) float64 {
 }

 func ModelRatio2JSONString() string {
-	jsonBytes, err := json.Marshal(ModelRatio)
+	if modelRatio == nil {
+		modelRatio = DefaultModelRatio
+	}
+	jsonBytes, err := json.Marshal(modelRatio)
 	if err != nil {
 		SysError("error marshalling model ratio: " + err.Error())
 	}
@@ -140,15 +174,18 @@ func ModelRatio2JSONString() string {
 }

 func UpdateModelRatioByJSONString(jsonStr string) error {
-	ModelRatio = make(map[string]float64)
-	return json.Unmarshal([]byte(jsonStr), &ModelRatio)
+	modelRatio = make(map[string]float64)
+	return json.Unmarshal([]byte(jsonStr), &modelRatio)
 }

 func GetModelRatio(name string) float64 {
+	if modelRatio == nil {
+		modelRatio = DefaultModelRatio
+	}
 	if strings.HasPrefix(name, "gpt-4-gizmo") {
 		name = "gpt-4-gizmo-*"
 	}
-	ratio, ok := ModelRatio[name]
+	ratio, ok := modelRatio[name]
 	if !ok {
 		SysError("model ratio not found: " + name)
 		return 30
@@ -158,35 +195,38 @@ func GetModelRatio(name string) float64 {

 func GetCompletionRatio(name string) float64 {
 	if strings.HasPrefix(name, "gpt-3.5") {
-		if strings.HasSuffix(name, "0125") {
+		if name == "gpt-3.5-turbo" || strings.HasSuffix(name, "0125") {
+			// https://openai.com/blog/new-embedding-models-and-api-updates
+			// Updated GPT-3.5 Turbo model and lower pricing
 			return 3
 		}
 		if strings.HasSuffix(name, "1106") {
 			return 2
 		}
-		if name == "gpt-3.5-turbo" || name == "gpt-3.5-turbo-16k" {
-			// TODO: clear this after 2023-12-11
-			now := time.Now()
-			// https://platform.openai.com/docs/models/continuous-model-upgrades
-			// if after 2023-12-11, use 2
-			if now.After(time.Date(2023, 12, 11, 0, 0, 0, 0, time.UTC)) {
-				return 2
-			}
-		}
-		return 1.333333
+		return 4.0 / 3.0
 	}
 	if strings.HasPrefix(name, "gpt-4") {
-		if strings.HasSuffix(name, "preview") {
+		if strings.HasPrefix(name, "gpt-4-turbo") || strings.HasSuffix(name, "preview") {
 			return 3
 		}
 		return 2
 	}
-	if strings.HasPrefix(name, "claude-instant-1") {
+	if strings.Contains(name, "claude-instant-1") {
 		return 3
-	} else if strings.HasPrefix(name, "claude-2") {
+	} else if strings.Contains(name, "claude-2") {
 		return 3
-	} else if strings.HasPrefix(name, "claude-3") {
+	} else if strings.Contains(name, "claude-3") {
 		return 5
 	}
+	if strings.HasPrefix(name, "mistral-") {
+		return 3
+	}
+	if strings.HasPrefix(name, "gemini-") {
+		return 3
+	}
+	switch name {
+	case "llama2-70b-4096":
+		return 0.8 / 0.7
+	}
 	return 1
 }
--- a/common/redis.go
+++ b/common/redis.go
@@ -18,9 +18,8 @@ func InitRedisClient() (err error) {
 		return nil
 	}
 	if os.Getenv("SYNC_FREQUENCY") == "" {
-		RedisEnabled = false
-		SysLog("SYNC_FREQUENCY not set, Redis is disabled")
-		return nil
+		SysLog("SYNC_FREQUENCY not set, use default value 60")
+		SyncFrequency = 60
 	}
 	SysLog("Redis is enabled")
 	opt, err := redis.ParseURL(os.Getenv("REDIS_CONN_STRING"))
--- a/common/str.go
+++ b/common/str.go
@@ -0,0 +1,50 @@
+package common
+
+func SundaySearch(text string, pattern string) bool {
+	// 计算偏移表
+	offset := make(map[rune]int)
+	for i, c := range pattern {
+		offset[c] = len(pattern) - i
+	}
+
+	// 文本串长度和模式串长度
+	n, m := len(text), len(pattern)
+
+	// 主循环，i表示当前对齐的文本串位置
+	for i := 0; i <= n-m; {
+		// 检查子串
+		j := 0
+		for j < m && text[i+j] == pattern[j] {
+			j++
+		}
+		// 如果完全匹配，返回匹配位置
+		if j == m {
+			return true
+		}
+
+		// 如果还有剩余字符，则检查下一位字符在偏移表中的值
+		if i+m < n {
+			next := rune(text[i+m])
+			if val, ok := offset[next]; ok {
+				i += val // 存在于偏移表中，进行跳跃
+			} else {
+				i += len(pattern) + 1 // 不存在于偏移表中，跳过整个模式串长度
+			}
+		} else {
+			break
+		}
+	}
+	return false // 如果没有找到匹配，返回-1
+}
+
+func RemoveDuplicate(s []string) []string {
+	result := make([]string, 0, len(s))
+	temp := map[string]struct{}{}
+	for _, item := range s {
+		if _, ok := temp[item]; !ok {
+			temp[item] = struct{}{}
+			result = append(result, item)
+		}
+	}
+	return result
+}
--- a/common/utils.go
+++ b/common/utils.go
@@ -236,3 +236,8 @@ func StringToByteSlice(s string) []byte {
 	tmp2 := [3]uintptr{tmp1[0], tmp1[1], tmp1[1]}
 	return *(*[]byte)(unsafe.Pointer(&tmp2))
 }
+
+func RandomSleep() {
+	// Sleep for 0-3000 ms
+	time.Sleep(time.Duration(rand.Intn(3000)) * time.Millisecond)
+}
--- a/constant/midjourney.go
+++ b/constant/midjourney.go
@@ -0,0 +1,46 @@
+package constant
+
+var MjNotifyEnabled = false
+var MjModeClearEnabled = false
+var MjForwardUrlEnabled = true
+
+const (
+	MjErrorUnknown = 5
+	MjRequestError = 4
+)
+
+const (
+	MjActionImagine       = "IMAGINE"
+	MjActionDescribe      = "DESCRIBE"
+	MjActionBlend         = "BLEND"
+	MjActionUpscale       = "UPSCALE"
+	MjActionVariation     = "VARIATION"
+	MjActionReRoll        = "REROLL"
+	MjActionInPaint       = "INPAINT"
+	MjActionModal         = "MODAL"
+	MjActionZoom          = "ZOOM"
+	MjActionCustomZoom    = "CUSTOM_ZOOM"
+	MjActionShorten       = "SHORTEN"
+	MjActionHighVariation = "HIGH_VARIATION"
+	MjActionLowVariation  = "LOW_VARIATION"
+	MjActionPan           = "PAN"
+	MjActionSwapFace      = "SWAP_FACE"
+)
+
+var MidjourneyModel2Action = map[string]string{
+	"mj_imagine":        MjActionImagine,
+	"mj_describe":       MjActionDescribe,
+	"mj_blend":          MjActionBlend,
+	"mj_upscale":        MjActionUpscale,
+	"mj_variation":      MjActionVariation,
+	"mj_reroll":         MjActionReRoll,
+	"mj_modal":          MjActionModal,
+	"mj_inpaint":        MjActionInPaint,
+	"mj_zoom":           MjActionZoom,
+	"mj_custom_zoom":    MjActionCustomZoom,
+	"mj_shorten":        MjActionShorten,
+	"mj_high_variation": MjActionHighVariation,
+	"mj_low_variation":  MjActionLowVariation,
+	"mj_pan":            MjActionPan,
+	"swap_face":         MjActionSwapFace,
+}
--- a/constant/payment.go
+++ b/constant/payment.go
@@ -0,0 +1,8 @@
+package constant
+
+var PayAddress = ""
+var CustomCallbackAddress = ""
+var EpayId = ""
+var EpayKey = ""
+var Price = 7.3
+var MinTopUp = 1
--- a/constant/sensitive.go
+++ b/constant/sensitive.go
@@ -0,0 +1,43 @@
+package constant
+
+import "strings"
+
+var CheckSensitiveEnabled = true
+var CheckSensitiveOnPromptEnabled = true
+
+//var CheckSensitiveOnCompletionEnabled = true
+
+// StopOnSensitiveEnabled 如果检测到敏感词，是否立刻停止生成，否则替换敏感词
+var StopOnSensitiveEnabled = true
+
+// StreamCacheQueueLength 流模式缓存队列长度，0表示无缓存
+var StreamCacheQueueLength = 0
+
+// SensitiveWords 敏感词
+// var SensitiveWords []string
+var SensitiveWords = []string{
+	"test",
+}
+
+func SensitiveWordsToString() string {
+	return strings.Join(SensitiveWords, "\n")
+}
+
+func SensitiveWordsFromString(s string) {
+	SensitiveWords = []string{}
+	sw := strings.Split(s, "\n")
+	for _, w := range sw {
+		w = strings.TrimSpace(w)
+		if w != "" {
+			SensitiveWords = append(SensitiveWords, w)
+		}
+	}
+}
+
+func ShouldCheckPromptSensitive() bool {
+	return CheckSensitiveEnabled && CheckSensitiveOnPromptEnabled
+}
+
+//func ShouldCheckCompletionSensitive() bool {
+//	return CheckSensitiveEnabled && CheckSensitiveOnCompletionEnabled
+//}
--- a/controller/channel-billing.go
+++ b/controller/channel-billing.go
@@ -214,10 +214,8 @@ func updateChannelBalance(channel *model.Channel) (float64, error) {
 		return 0, errors.New("尚未实现")
 	case common.ChannelTypeCustom:
 		baseURL = channel.GetBaseURL()
-	case common.ChannelTypeCloseAI:
-		return updateChannelCloseAIBalance(channel)
-	case common.ChannelTypeOpenAISB:
-		return updateChannelOpenAISBBalance(channel)
+	//case common.ChannelTypeOpenAISB:
+	//	return updateChannelOpenAISBBalance(channel)
 	case common.ChannelTypeAIProxy:
 		return updateChannelAIProxyBalance(channel)
 	case common.ChannelTypeAPI2GPT:
--- a/controller/channel-test.go
+++ b/controller/channel-test.go
@@ -27,7 +27,6 @@ func testChannel(channel *model.Channel, testModel string) (err error, openaiErr
 	if channel.Type == common.ChannelTypeMidjourney {
 		return errors.New("midjourney channel test is not supported"), nil
 	}
-	common.SysLog(fmt.Sprintf("testing channel %d with model %s", channel.Id, testModel))
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
 	c.Request = &http.Request{
@@ -60,12 +59,16 @@ func testChannel(channel *model.Channel, testModel string) (err error, openaiErr
 		return fmt.Errorf("invalid api type: %d, adaptor is nil", apiType), nil
 	}
 	if testModel == "" {
-		testModel = adaptor.GetModelList()[0]
-		meta.UpstreamModelName = testModel
+		if channel.TestModel != nil && *channel.TestModel != "" {
+			testModel = *channel.TestModel
+		} else {
+			testModel = adaptor.GetModelList()[0]
+		}
 	}
 	request := buildTestRequest()
 	request.Model = testModel
 	meta.UpstreamModelName = testModel
+	common.SysLog(fmt.Sprintf("testing channel %d with model %s", channel.Id, testModel))

 	adaptor.Init(meta, *request)

@@ -83,7 +86,7 @@ func testChannel(channel *model.Channel, testModel string) (err error, openaiErr
 	if err != nil {
 		return err, nil
 	}
-	if resp.StatusCode != http.StatusOK {
+	if resp != nil && resp.StatusCode != http.StatusOK {
 		err := relaycommon.RelayErrorHandler(resp)
 		return fmt.Errorf("status code %d: %s", resp.StatusCode, err.Error.Message), &err.Error
 	}
@@ -108,6 +111,7 @@ func buildTestRequest() *dto.GeneralOpenAIRequest {
 	testRequest := &dto.GeneralOpenAIRequest{
 		Model:     "", // this will be set later
 		MaxTokens: 1,
+		Stream:    false,
 	}
 	content, _ := json.Marshal("hi")
 	testMessage := dto.Message{
--- a/controller/log.go
+++ b/controller/log.go
@@ -10,9 +10,13 @@ import (

 func GetAllLogs(c *gin.Context) {
 	p, _ := strconv.Atoi(c.Query("p"))
+	pageSize, _ := strconv.Atoi(c.Query("page_size"))
 	if p < 0 {
 		p = 0
 	}
+	if pageSize < 0 {
+		pageSize = common.ItemsPerPage
+	}
 	logType, _ := strconv.Atoi(c.Query("type"))
 	startTimestamp, _ := strconv.ParseInt(c.Query("start_timestamp"), 10, 64)
 	endTimestamp, _ := strconv.ParseInt(c.Query("end_timestamp"), 10, 64)
@@ -20,7 +24,7 @@ func GetAllLogs(c *gin.Context) {
 	tokenName := c.Query("token_name")
 	modelName := c.Query("model_name")
 	channel, _ := strconv.Atoi(c.Query("channel"))
-	logs, err := model.GetAllLogs(logType, startTimestamp, endTimestamp, modelName, username, tokenName, p*common.ItemsPerPage, common.ItemsPerPage, channel)
+	logs, err := model.GetAllLogs(logType, startTimestamp, endTimestamp, modelName, username, tokenName, p*pageSize, pageSize, channel)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
@@ -38,16 +42,23 @@ func GetAllLogs(c *gin.Context) {

 func GetUserLogs(c *gin.Context) {
 	p, _ := strconv.Atoi(c.Query("p"))
+	pageSize, _ := strconv.Atoi(c.Query("page_size"))
 	if p < 0 {
 		p = 0
 	}
+	if pageSize < 0 {
+		pageSize = common.ItemsPerPage
+	}
+	if pageSize > 100 {
+		pageSize = 100
+	}
 	userId := c.GetInt("id")
 	logType, _ := strconv.Atoi(c.Query("type"))
 	startTimestamp, _ := strconv.ParseInt(c.Query("start_timestamp"), 10, 64)
 	endTimestamp, _ := strconv.ParseInt(c.Query("end_timestamp"), 10, 64)
 	tokenName := c.Query("token_name")
 	modelName := c.Query("model_name")
-	logs, err := model.GetUserLogs(userId, logType, startTimestamp, endTimestamp, modelName, tokenName, p*common.ItemsPerPage, common.ItemsPerPage)
+	logs, err := model.GetUserLogs(userId, logType, startTimestamp, endTimestamp, modelName, tokenName, p*pageSize, pageSize)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
--- a/controller/midjourney.go
+++ b/controller/midjourney.go
@@ -10,145 +10,14 @@ import (
 	"log"
 	"net/http"
 	"one-api/common"
+	"one-api/constant"
+	"one-api/dto"
 	"one-api/model"
-	relay2 "one-api/relay"
 	"one-api/service"
 	"strconv"
-	"strings"
 	"time"
 )

-/*func UpdateMidjourneyTask() {
-	//revocer
-	//imageModel := "midjourney"
-	ctx := context.TODO()
-	imageModel := "midjourney"
-	defer func() {
-		if err := recover(); err != nil {
-			log.Printf("UpdateMidjourneyTask panic: %v", err)
-		}
-	}()
-	for {
-		time.Sleep(time.Duration(15) * time.Second)
-		tasks := model.GetAllUnFinishTasks()
-		if len(tasks) != 0 {
-			common.LogInfo(ctx, fmt.Sprintf("检测到未完成的任务数有: %v", len(tasks)))
-			for _, task := range tasks {
-				common.LogInfo(ctx, fmt.Sprintf("未完成的任务信息: %v", task))
-				midjourneyChannel, err := model.GetChannelById(task.ChannelId, true)
-				if err != nil {
-					common.LogError(ctx, fmt.Sprintf("UpdateMidjourneyTask: %v", err))
-					task.FailReason = fmt.Sprintf("获取渠道信息失败，请联系管理员，渠道ID：%d", task.ChannelId)
-					task.Status = "FAILURE"
-					task.Progress = "100%"
-					err := task.Update()
-					if err != nil {
-						common.LogInfo(ctx, fmt.Sprintf("UpdateMidjourneyTask error: %v", err))
-						continue
-					}
-					continue
-				}
-				requestUrl := fmt.Sprintf("%s/mj/task/%s/fetch", *midjourneyChannel.BaseURL, task.MjId)
-				common.LogInfo(ctx, fmt.Sprintf("requestUrl: %s", requestUrl))
-
-				req, err := http.NewRequest("GET", requestUrl, bytes.NewBuffer([]byte("")))
-				if err != nil {
-					common.LogInfo(ctx, fmt.Sprintf("Get Task error: %v", err))
-					continue
-				}
-
-				// 设置超时时间
-				timeout := time.Second * 5
-				ctx, cancel := context.WithTimeout(context.Background(), timeout)
-
-				// 使用带有超时的 context 创建新的请求
-				req = req.WithContext(ctx)
-
-				req.Header.Set("Content-Type", "application/json")
-				//req.Header.Set("ApiKey", "Bearer midjourney-proxy")
-				req.Header.Set("mj-api-secret", midjourneyChannel.Key)
-				resp, err := httpClient.Do(req)
-				if err != nil {
-					log.Printf("UpdateMidjourneyTask error: %v", err)
-					continue
-				}
-				responseBody, err := io.ReadAll(resp.Body)
-				resp.Body.Close()
-				log.Printf("responseBody: %s", string(responseBody))
-				var responseItem Midjourney
-				// err = json.NewDecoder(resp.Body).Decode(&responseItem)
-				err = json.Unmarshal(responseBody, &responseItem)
-				if err != nil {
-					if strings.Contains(err.Error(), "cannot unmarshal number into Go struct field Midjourney.status of type string") {
-						var responseWithoutStatus MidjourneyWithoutStatus
-						var responseStatus MidjourneyStatus
-						err1 := json.Unmarshal(responseBody, &responseWithoutStatus)
-						err2 := json.Unmarshal(responseBody, &responseStatus)
-						if err1 == nil && err2 == nil {
-							jsonData, err3 := json.Marshal(responseWithoutStatus)
-							if err3 != nil {
-								log.Printf("UpdateMidjourneyTask error1: %v", err3)
-								continue
-							}
-							err4 := json.Unmarshal(jsonData, &responseStatus)
-							if err4 != nil {
-								log.Printf("UpdateMidjourneyTask error2: %v", err4)
-								continue
-							}
-							responseItem.Status = strconv.Itoa(responseStatus.Status)
-						} else {
-							log.Printf("UpdateMidjourneyTask error3: %v", err)
-							continue
-						}
-					} else {
-						log.Printf("UpdateMidjourneyTask error4: %v", err)
-						continue
-					}
-				}
-				task.Code = 1
-				task.Progress = responseItem.Progress
-				task.PromptEn = responseItem.PromptEn
-				task.State = responseItem.State
-				task.SubmitTime = responseItem.SubmitTime
-				task.StartTime = responseItem.StartTime
-				task.FinishTime = responseItem.FinishTime
-				task.ImageUrl = responseItem.ImageUrl
-				task.Status = responseItem.Status
-				task.FailReason = responseItem.FailReason
-				if task.Progress != "100%" && responseItem.FailReason != "" {
-					common.LogWarn(task.MjId + " 构建失败，" + task.FailReason)
-					task.Progress = "100%"
-					err = model.CacheUpdateUserQuota(task.UserId)
-					if err != nil {
-						log.Println("error update user quota cache: " + err.Error())
-					} else {
-						modelRatio := common.GetModelRatio(imageModel)
-						groupRatio := common.GetGroupRatio("default")
-						ratio := modelRatio * groupRatio
-						quota := int(ratio * 1 * 1000)
-						if quota != 0 {
-							err := model.IncreaseUserQuota(task.UserId, quota)
-							if err != nil {
-								log.Println("fail to increase user quota")
-							}
-							logContent := fmt.Sprintf("构图失败 %s，补偿 %s", task.MjId, common.LogQuota(quota))
-							model.RecordLog(task.UserId, model.LogTypeSystem, logContent)
-						}
-					}
-				}
-
-				err = task.Update()
-				if err != nil {
-					log.Printf("UpdateMidjourneyTask error5: %v", err)
-				}
-				log.Printf("UpdateMidjourneyTask success: %v", task)
-				cancel()
-			}
-		}
-	}
-}
-*/
-
 func UpdateMidjourneyTaskBulk() {
 	//imageModel := "midjourney"
 	ctx := context.TODO()
@@ -228,12 +97,16 @@ func UpdateMidjourneyTaskBulk() {
 				common.LogError(ctx, fmt.Sprintf("Get Task Do req error: %v", err))
 				continue
 			}
+			if resp.StatusCode != http.StatusOK {
+				common.LogError(ctx, fmt.Sprintf("Get Task status code: %d", resp.StatusCode))
+				continue
+			}
 			responseBody, err := io.ReadAll(resp.Body)
 			if err != nil {
 				common.LogError(ctx, fmt.Sprintf("Get Task parse body error: %v", err))
 				continue
 			}
-			var responseItems []relay2.Midjourney
+			var responseItems []dto.MidjourneyDto
 			err = json.Unmarshal(responseBody, &responseItems)
 			if err != nil {
 				common.LogError(ctx, fmt.Sprintf("Get Task parse body error2: %v, body: %s", err, string(responseBody)))
@@ -245,10 +118,16 @@ func UpdateMidjourneyTaskBulk() {

 			for _, responseItem := range responseItems {
 				task := taskM[responseItem.MjId]
+
+				useTime := (time.Now().UnixNano() / int64(time.Millisecond)) - task.SubmitTime
+				// 如果时间超过一小时，且进度不是100%，则认为任务失败
+				if useTime > 3600000 && task.Progress != "100%" {
+					responseItem.FailReason = "上游任务超时（超过1小时）"
+					responseItem.Status = "FAILURE"
+				}
 				if !checkMjTaskNeedUpdate(task, responseItem) {
 					continue
 				}
-
 				task.Code = 1
 				task.Progress = responseItem.Progress
 				task.PromptEn = responseItem.PromptEn
@@ -259,7 +138,16 @@ func UpdateMidjourneyTaskBulk() {
 				task.ImageUrl = responseItem.ImageUrl
 				task.Status = responseItem.Status
 				task.FailReason = responseItem.FailReason
-				if task.Progress != "100%" && responseItem.FailReason != "" {
+				if responseItem.Properties != nil {
+					propertiesStr, _ := json.Marshal(responseItem.Properties)
+					task.Properties = string(propertiesStr)
+				}
+				if responseItem.Buttons != nil {
+					buttonStr, _ := json.Marshal(responseItem.Buttons)
+					task.Buttons = string(buttonStr)
+				}
+
+				if (task.Progress != "100%" && responseItem.FailReason != "") || (task.Progress == "100%" && task.Status == "FAILURE") {
 					common.LogInfo(ctx, task.MjId+" 构建失败，"+task.FailReason)
 					task.Progress = "100%"
 					err = model.CacheUpdateUserQuota(task.UserId)
@@ -286,7 +174,7 @@ func UpdateMidjourneyTaskBulk() {
 	}
 }

-func checkMjTaskNeedUpdate(oldTask *model.Midjourney, newTask relay2.Midjourney) bool {
+func checkMjTaskNeedUpdate(oldTask *model.Midjourney, newTask dto.MidjourneyDto) bool {
 	if oldTask.Code != 1 {
 		return true
 	}
@@ -345,6 +233,12 @@ func GetAllMidjourney(c *gin.Context) {
 	if logs == nil {
 		logs = make([]*model.Midjourney, 0)
 	}
+	if constant.MjForwardUrlEnabled {
+		for i, midjourney := range logs {
+			midjourney.ImageUrl = common.ServerAddress + "/mj/image/" + midjourney.MjId
+			logs[i] = midjourney
+		}
+	}
 	c.JSON(200, gin.H{
 		"success": true,
 		"message": "",
@@ -371,7 +265,7 @@ func GetUserMidjourney(c *gin.Context) {
 	if logs == nil {
 		logs = make([]*model.Midjourney, 0)
 	}
-	if !strings.Contains(common.ServerAddress, "localhost") {
+	if constant.MjForwardUrlEnabled {
 		for i, midjourney := range logs {
 			midjourney.ImageUrl = common.ServerAddress + "/mj/image/" + midjourney.MjId
 			logs[i] = midjourney
--- a/controller/misc.go
+++ b/controller/misc.go
@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"net/http"
 	"one-api/common"
+	"one-api/constant"
 	"one-api/model"
 	"strings"

@@ -32,6 +33,7 @@ func GetStatus(c *gin.Context) {
 		"success": true,
 		"message": "",
 		"data": gin.H{
+			"version":                  common.Version,
 			"start_time":               common.StartTime,
 			"email_verification":       common.EmailVerificationEnabled,
 			"github_oauth":             common.GitHubOAuthEnabled,
@@ -44,8 +46,8 @@ func GetStatus(c *gin.Context) {
 			"wechat_qrcode":            common.WeChatAccountQRCodeImageURL,
 			"wechat_login":             common.WeChatAuthEnabled,
 			"server_address":           common.ServerAddress,
-			"price":                    common.Price,
-			"min_topup":                common.MinTopUp,
+			"price":                    constant.Price,
+			"min_topup":                constant.MinTopUp,
 			"turnstile_check":          common.TurnstileCheckEnabled,
 			"turnstile_site_key":       common.TurnstileSiteKey,
 			"top_up_link":              common.TopUpLink,
@@ -58,7 +60,8 @@ func GetStatus(c *gin.Context) {
 			"enable_data_export":       common.DataExportEnabled,
 			"data_export_default_time": common.DataExportDefaultTime,
 			"default_collapse_sidebar": common.DefaultCollapseSidebar,
-			"enable_online_topup":      common.PayAddress != "" && common.EpayId != "" && common.EpayKey != "",
+			"enable_online_topup":      constant.PayAddress != "" && constant.EpayId != "" && constant.EpayKey != "",
+			"mj_notify_enabled":        constant.MjNotifyEnabled,
 		},
 	})
 	return
@@ -117,10 +120,20 @@ func SendEmailVerification(c *gin.Context) {
 		})
 		return
 	}
+	parts := strings.Split(email, "@")
+	if len(parts) != 2 {
+		c.JSON(http.StatusOK, gin.H{
+			"success": false,
+			"message": "无效的邮箱地址",
+		})
+		return
+	}
+	localPart := parts[0]
+	domainPart := parts[1]
 	if common.EmailDomainRestrictionEnabled {
 		allowed := false
 		for _, domain := range common.EmailDomainWhitelist {
-			if strings.HasSuffix(email, "@"+domain) {
+			if domainPart == domain {
 				allowed = true
 				break
 			}
@@ -128,11 +141,22 @@ func SendEmailVerification(c *gin.Context) {
 		if !allowed {
 			c.JSON(http.StatusOK, gin.H{
 				"success": false,
-				"message": "管理员启用了邮箱域名白名单，您的邮箱地址的域名不在白名单中",
+				"message": "The administrator has enabled the email domain name whitelist, and your email address is not allowed due to special symbols or it's not in the whitelist.",
 			})
 			return
 		}
 	}
+	if common.EmailAliasRestrictionEnabled {
+		containsSpecialSymbols := strings.Contains(localPart, "+") || strings.Count(localPart, ".") > 1
+		if containsSpecialSymbols {
+			c.JSON(http.StatusOK, gin.H{
+				"success": false,
+				"message": "管理员已启用邮箱地址别名限制，您的邮箱地址由于包含特殊符号而被拒绝。",
+			})
+			return
+		}
+	}
+
 	if model.IsEmailAlreadyTaken(email) {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
--- a/controller/model.go
+++ b/controller/model.go
@@ -4,12 +4,14 @@ import (
 	"fmt"
 	"github.com/gin-gonic/gin"
 	"net/http"
+	"one-api/constant"
 	"one-api/dto"
 	"one-api/model"
 	"one-api/relay"
 	"one-api/relay/channel/ai360"
 	"one-api/relay/channel/moonshot"
-	"one-api/relay/constant"
+	"one-api/relay/channel/lingyiwanwu"
+	relayconstant "one-api/relay/constant"
 )

 // https://platform.openai.com/docs/api-reference/models/list
@@ -59,8 +61,8 @@ func init() {
 		IsBlocking:         false,
 	})
 	// https://platform.openai.com/docs/models/model-endpoint-compatibility
-	for i := 0; i < constant.APITypeDummy; i++ {
-		if i == constant.APITypeAIProxyLibrary {
+	for i := 0; i < relayconstant.APITypeDummy; i++ {
+		if i == relayconstant.APITypeAIProxyLibrary {
 			continue
 		}
 		adaptor := relay.GetAdaptor(i)
@@ -100,6 +102,28 @@ func init() {
 			Parent:     nil,
 		})
 	}
+	for _, modelName := range lingyiwanwu.ModelList {
+		openAIModels = append(openAIModels, OpenAIModels{
+			Id:         modelName,
+			Object:     "model",
+			Created:    1626777600,
+			OwnedBy:    "lingyiwanwu",
+			Permission: permission,
+			Root:       modelName,
+			Parent:     nil,
+		})
+	}
+	for modelName, _ := range constant.MidjourneyModel2Action {
+		openAIModels = append(openAIModels, OpenAIModels{
+			Id:         modelName,
+			Object:     "model",
+			Created:    1626777600,
+			OwnedBy:    "midjourney",
+			Permission: permission,
+			Root:       modelName,
+			Parent:     nil,
+		})
+	}
 	openAIModelsMap = make(map[string]OpenAIModels)
 	for _, model := range openAIModels {
 		openAIModelsMap[model.Id] = model
--- a/controller/option.go
+++ b/controller/option.go
@@ -14,7 +14,7 @@ func GetOptions(c *gin.Context) {
 	var options []*model.Option
 	common.OptionMapRWMutex.Lock()
 	for k, v := range common.OptionMap {
-		if strings.HasSuffix(k, "Token") || strings.HasSuffix(k, "Secret") {
+		if strings.HasSuffix(k, "Token") || strings.HasSuffix(k, "Secret") || strings.HasSuffix(k, "Key") {
 			continue
 		}
 		options = append(options, &model.Option{
--- a/controller/relay.go
+++ b/controller/relay.go
@@ -1,22 +1,24 @@
 package controller

 import (
+	"bytes"
 	"fmt"
 	"github.com/gin-gonic/gin"
+	"io"
 	"log"
 	"net/http"
 	"one-api/common"
 	"one-api/dto"
+	"one-api/middleware"
+	"one-api/model"
 	"one-api/relay"
 	"one-api/relay/constant"
 	relayconstant "one-api/relay/constant"
 	"one-api/service"
-	"strconv"
 	"strings"
 )

-func Relay(c *gin.Context) {
-	relayMode := constant.Path2RelayMode(c.Request.URL.Path)
+func relayHandler(c *gin.Context, relayMode int) *dto.OpenAIErrorWithStatusCode {
 	var err *dto.OpenAIErrorWithStatusCode
 	switch relayMode {
 	case relayconstant.RelayModeImagesGenerations:
@@ -30,91 +32,131 @@ func Relay(c *gin.Context) {
 	default:
 		err = relay.TextHelper(c)
 	}
-	if err != nil {
-		requestId := c.GetString(common.RequestIdKey)
-		retryTimesStr := c.Query("retry")
-		retryTimes, _ := strconv.Atoi(retryTimesStr)
-		if retryTimesStr == "" {
-			retryTimes = common.RetryTimes
+	return err
+}
+
+func Relay(c *gin.Context) {
+	relayMode := constant.Path2RelayMode(c.Request.URL.Path)
+	retryTimes := common.RetryTimes
+	requestId := c.GetString(common.RequestIdKey)
+	channelId := c.GetInt("channel_id")
+	group := c.GetString("group")
+	originalModel := c.GetString("original_model")
+	openaiErr := relayHandler(c, relayMode)
+	useChannel := []int{channelId}
+	if openaiErr != nil {
+		go processChannelError(c, channelId, openaiErr)
+	} else {
+		retryTimes = 0
+	}
+	for i := 0; shouldRetry(c, channelId, openaiErr, retryTimes) && i < retryTimes; i++ {
+		channel, err := model.CacheGetRandomSatisfiedChannel(group, originalModel, i)
+		if err != nil {
+			common.LogError(c.Request.Context(), fmt.Sprintf("CacheGetRandomSatisfiedChannel failed: %s", err.Error()))
+			break
 		}
-		if retryTimes > 0 {
-			c.Redirect(http.StatusTemporaryRedirect, fmt.Sprintf("%s?retry=%d&error=%s", c.Request.URL.Path, retryTimes-1, err.Error.Message))
-		} else {
-			if err.StatusCode == http.StatusTooManyRequests {
-				//err.Error.Message = "当前分组上游负载已饱和，请稍后再试"
-			}
-			err.Error.Message = common.MessageWithRequestId(err.Error.Message, requestId)
-			c.JSON(err.StatusCode, gin.H{
-				"error": err.Error,
-			})
+		channelId = channel.Id
+		useChannel = append(useChannel, channelId)
+		common.LogInfo(c.Request.Context(), fmt.Sprintf("using channel #%d to retry (remain times %d)", channel.Id, i))
+		middleware.SetupContextForSelectedChannel(c, channel, originalModel)
+
+		requestBody, err := common.GetRequestBody(c)
+		c.Request.Body = io.NopCloser(bytes.NewBuffer(requestBody))
+		openaiErr = relayHandler(c, relayMode)
+		if openaiErr != nil {
+			go processChannelError(c, channelId, openaiErr)
 		}
-		channelId := c.GetInt("channel_id")
-		autoBan := c.GetBool("auto_ban")
-		common.LogError(c.Request.Context(), fmt.Sprintf("relay error (channel #%d): %s", channelId, err.Error.Message))
-		// https://platform.openai.com/docs/guides/error-codes/api-errors
-		if service.ShouldDisableChannel(&err.Error, err.StatusCode) && autoBan {
-			channelId := c.GetInt("channel_id")
-			channelName := c.GetString("channel_name")
-			service.DisableChannel(channelId, channelName, err.Error.Message)
+	}
+	if len(useChannel) > 1 {
+		retryLogStr := fmt.Sprintf("重试：%s", strings.Trim(strings.Join(strings.Fields(fmt.Sprint(useChannel)), "->"), "[]"))
+		common.LogInfo(c.Request.Context(), retryLogStr)
+	}
+
+	if openaiErr != nil {
+		if openaiErr.StatusCode == http.StatusTooManyRequests {
+			openaiErr.Error.Message = "当前分组上游负载已饱和，请稍后再试"
 		}
+		openaiErr.Error.Message = common.MessageWithRequestId(openaiErr.Error.Message, requestId)
+		c.JSON(openaiErr.StatusCode, gin.H{
+			"error": openaiErr.Error,
+		})
+	}
+}
+
+func shouldRetry(c *gin.Context, channelId int, openaiErr *dto.OpenAIErrorWithStatusCode, retryTimes int) bool {
+	if openaiErr == nil {
+		return false
+	}
+	if retryTimes <= 0 {
+		return false
+	}
+	if _, ok := c.Get("specific_channel_id"); ok {
+		return false
+	}
+	if openaiErr.StatusCode == http.StatusTooManyRequests {
+		return true
+	}
+	if openaiErr.StatusCode == 307 {
+		return true
+	}
+	if openaiErr.StatusCode/100 == 5 {
+		// 超时不重试
+		if openaiErr.StatusCode == 504 || openaiErr.StatusCode == 524 {
+			return false
+		}
+		return true
+	}
+	if openaiErr.StatusCode == http.StatusBadRequest {
+		return false
+	}
+	if openaiErr.LocalError {
+		return false
+	}
+	if openaiErr.StatusCode/100 == 2 {
+		return false
+	}
+	return true
+}
+
+func processChannelError(c *gin.Context, channelId int, err *dto.OpenAIErrorWithStatusCode) {
+	autoBan := c.GetBool("auto_ban")
+	common.LogError(c.Request.Context(), fmt.Sprintf("relay error (channel #%d): %s", channelId, err.Error.Message))
+	if service.ShouldDisableChannel(&err.Error, err.StatusCode) && autoBan {
+		channelName := c.GetString("channel_name")
+		service.DisableChannel(channelId, channelName, err.Error.Message)
 	}
 }

 func RelayMidjourney(c *gin.Context) {
-	relayMode := relayconstant.RelayModeUnknown
-	if strings.HasPrefix(c.Request.URL.Path, "/mj/submit/imagine") {
-		relayMode = relayconstant.RelayModeMidjourneyImagine
-	} else if strings.HasPrefix(c.Request.URL.Path, "/mj/submit/blend") {
-		relayMode = relayconstant.RelayModeMidjourneyBlend
-	} else if strings.HasPrefix(c.Request.URL.Path, "/mj/submit/describe") {
-		relayMode = relayconstant.RelayModeMidjourneyDescribe
-	} else if strings.HasPrefix(c.Request.URL.Path, "/mj/notify") {
-		relayMode = relayconstant.RelayModeMidjourneyNotify
-	} else if strings.HasPrefix(c.Request.URL.Path, "/mj/submit/change") {
-		relayMode = relayconstant.RelayModeMidjourneyChange
-	} else if strings.HasPrefix(c.Request.URL.Path, "/mj/submit/simple-change") {
-		relayMode = relayconstant.RelayModeMidjourneyChange
-	} else if strings.HasSuffix(c.Request.URL.Path, "/fetch") {
-		relayMode = relayconstant.RelayModeMidjourneyTaskFetch
-	} else if strings.HasSuffix(c.Request.URL.Path, "/list-by-condition") {
-		relayMode = relayconstant.RelayModeMidjourneyTaskFetchByCondition
-	}
-
+	relayMode := c.GetInt("relay_mode")
 	var err *dto.MidjourneyResponse
 	switch relayMode {
 	case relayconstant.RelayModeMidjourneyNotify:
 		err = relay.RelayMidjourneyNotify(c)
 	case relayconstant.RelayModeMidjourneyTaskFetch, relayconstant.RelayModeMidjourneyTaskFetchByCondition:
 		err = relay.RelayMidjourneyTask(c, relayMode)
+	case relayconstant.RelayModeMidjourneyTaskImageSeed:
+		err = relay.RelayMidjourneyTaskImageSeed(c)
+	case relayconstant.RelayModeSwapFace:
+		err = relay.RelaySwapFace(c)
 	default:
 		err = relay.RelayMidjourneySubmit(c, relayMode)
 	}
 	//err = relayMidjourneySubmit(c, relayMode)
 	log.Println(err)
 	if err != nil {
-		retryTimesStr := c.Query("retry")
-		retryTimes, _ := strconv.Atoi(retryTimesStr)
-		if retryTimesStr == "" {
-			retryTimes = common.RetryTimes
-		}
-		if retryTimes > 0 {
-			c.Redirect(http.StatusTemporaryRedirect, fmt.Sprintf("%s?retry=%d", c.Request.URL.Path, retryTimes-1))
-		} else {
-			if err.Code == 30 {
-				err.Result = "当前分组负载已饱和，请稍后再试，或升级账户以提升服务质量。"
-			}
-			c.JSON(429, gin.H{
-				"error": fmt.Sprintf("%s %s", err.Description, err.Result),
-				"type":  "upstream_error",
-			})
+		statusCode := http.StatusBadRequest
+		if err.Code == 30 {
+			err.Result = "当前分组负载已饱和，请稍后再试，或升级账户以提升服务质量。"
+			statusCode = http.StatusTooManyRequests
 		}
+		c.JSON(statusCode, gin.H{
+			"description": fmt.Sprintf("%s %s", err.Description, err.Result),
+			"type":        "upstream_error",
+			"code":        err.Code,
+		})
 		channelId := c.GetInt("channel_id")
 		common.SysError(fmt.Sprintf("relay error (channel #%d): %s", channelId, fmt.Sprintf("%s %s", err.Description, err.Result)))
-		//if shouldDisableChannel(&err.Error) {
-		//	channelId := c.GetInt("channel_id")
-		//	channelName := c.GetString("channel_name")
-		//	disableChannel(channelId, channelName, err.Result)
-		//};''''''''''''''''''''''''''''''''
 	}
 }

--- a/controller/topup.go
+++ b/controller/topup.go
@@ -2,15 +2,18 @@ package controller

 import (
 	"fmt"
+	"github.com/Calcium-Ion/go-epay/epay"
 	"github.com/gin-gonic/gin"
 	"github.com/samber/lo"
-	epay "github.com/star-horizon/go-epay"
+	"one-api/constant"
+
 	"log"
 	"net/url"
 	"one-api/common"
 	"one-api/model"
 	"one-api/service"
 	"strconv"
+	"sync"
 	"time"
 )

@@ -26,44 +29,59 @@ type AmountRequest struct {
 }

 func GetEpayClient() *epay.Client {
-	if common.PayAddress == "" || common.EpayId == "" || common.EpayKey == "" {
+	if constant.PayAddress == "" || constant.EpayId == "" || constant.EpayKey == "" {
 		return nil
 	}
-	withUrl, err := epay.NewClientWithUrl(&epay.Config{
-		PartnerID: common.EpayId,
-		Key:       common.EpayKey,
-	}, common.PayAddress)
+	withUrl, err := epay.NewClient(&epay.Config{
+		PartnerID: constant.EpayId,
+		Key:       constant.EpayKey,
+	}, constant.PayAddress)
 	if err != nil {
 		return nil
 	}
 	return withUrl
 }

-func GetAmount(count float64, user model.User) float64 {
+func getPayMoney(amount float64, user model.User) float64 {
+	if !common.DisplayInCurrencyEnabled {
+		amount = amount / common.QuotaPerUnit
+	}
 	// 别问为什么用float64，问就是这么点钱没必要
 	topupGroupRatio := common.GetTopupGroupRatio(user.Group)
 	if topupGroupRatio == 0 {
 		topupGroupRatio = 1
 	}
-	amount := count * common.Price * topupGroupRatio
-	return amount
+	payMoney := amount * constant.Price * topupGroupRatio
+	return payMoney
+}
+
+func getMinTopup() int {
+	minTopup := constant.MinTopUp
+	if !common.DisplayInCurrencyEnabled {
+		minTopup = minTopup * int(common.QuotaPerUnit)
+	}
+	return minTopup
 }

 func RequestEpay(c *gin.Context) {
 	var req EpayRequest
 	err := c.ShouldBindJSON(&req)
 	if err != nil {
-		c.JSON(200, gin.H{"message": err.Error(), "data": 10})
+		c.JSON(200, gin.H{"message": "error", "data": "参数错误"})
 		return
 	}
-	if req.Amount < common.MinTopUp {
-		c.JSON(200, gin.H{"message": fmt.Sprintf("充值数量不能小于 %d", common.MinTopUp), "data": 10})
+	if req.Amount < getMinTopup() {
+		c.JSON(200, gin.H{"message": "error", "data": fmt.Sprintf("充值数量不能小于 %d", getMinTopup())})
 		return
 	}

 	id := c.GetInt("id")
 	user, _ := model.GetUserById(id, false)
-	payMoney := GetAmount(float64(req.Amount), *user)
+	payMoney := getPayMoney(float64(req.Amount), *user)
+	if payMoney < 0.01 {
+		c.JSON(200, gin.H{"message": "error", "data": "充值金额过低"})
+		return
+	}

 	var payType epay.PurchaseType
 	if req.PaymentMethod == "zfb" {
@@ -76,7 +94,7 @@ func RequestEpay(c *gin.Context) {
 	callBackAddress := service.GetCallbackAddress()
 	returnUrl, _ := url.Parse(common.ServerAddress + "/log")
 	notifyUrl, _ := url.Parse(callBackAddress + "/api/user/epay/notify")
-	tradeNo := strconv.FormatInt(time.Now().Unix(), 10)
+	tradeNo := fmt.Sprintf("%s%d", common.GetRandomString(6), time.Now().Unix())
 	client := GetEpayClient()
 	if client == nil {
 		c.JSON(200, gin.H{"message": "error", "data": "当前管理员未配置支付信息"})
@@ -95,9 +113,13 @@ func RequestEpay(c *gin.Context) {
 		c.JSON(200, gin.H{"message": "error", "data": "拉起支付失败"})
 		return
 	}
+	amount := req.Amount
+	if !common.DisplayInCurrencyEnabled {
+		amount = amount / int(common.QuotaPerUnit)
+	}
 	topUp := &model.TopUp{
 		UserId:     id,
-		Amount:     req.Amount,
+		Amount:     amount,
 		Money:      payMoney,
 		TradeNo:    "A" + tradeNo,
 		CreateTime: time.Now().Unix(),
@@ -111,6 +133,33 @@ func RequestEpay(c *gin.Context) {
 	c.JSON(200, gin.H{"message": "success", "data": params, "url": uri})
 }

+// tradeNo lock
+var orderLocks sync.Map
+var createLock sync.Mutex
+
+// LockOrder 尝试对给定订单号加锁
+func LockOrder(tradeNo string) {
+	lock, ok := orderLocks.Load(tradeNo)
+	if !ok {
+		createLock.Lock()
+		defer createLock.Unlock()
+		lock, ok = orderLocks.Load(tradeNo)
+		if !ok {
+			lock = new(sync.Mutex)
+			orderLocks.Store(tradeNo, lock)
+		}
+	}
+	lock.(*sync.Mutex).Lock()
+}
+
+// UnlockOrder 释放给定订单号的锁
+func UnlockOrder(tradeNo string) {
+	lock, ok := orderLocks.Load(tradeNo)
+	if ok {
+		lock.(*sync.Mutex).Unlock()
+	}
+}
+
 func EpayNotify(c *gin.Context) {
 	params := lo.Reduce(lo.Keys(c.Request.URL.Query()), func(r map[string]string, t string, i int) map[string]string {
 		r[t] = c.Request.URL.Query().Get(t)
@@ -122,6 +171,7 @@ func EpayNotify(c *gin.Context) {
 		_, err := c.Writer.Write([]byte("fail"))
 		if err != nil {
 			log.Println("易支付回调写入失败")
+			return
 		}
 	}
 	verifyInfo, err := client.Verify(params)
@@ -135,11 +185,19 @@ func EpayNotify(c *gin.Context) {
 		if err != nil {
 			log.Println("易支付回调写入失败")
 		}
+		log.Println("易支付回调签名验证失败")
+		return
 	}

 	if verifyInfo.TradeStatus == epay.StatusTradeSuccess {
 		log.Println(verifyInfo)
+		LockOrder(verifyInfo.ServiceTradeNo)
+		defer UnlockOrder(verifyInfo.ServiceTradeNo)
 		topUp := model.GetTopUpByTradeNo(verifyInfo.ServiceTradeNo)
+		if topUp == nil {
+			log.Printf("易支付回调未找到订单: %v", verifyInfo)
+			return
+		}
 		if topUp.Status == "pending" {
 			topUp.Status = "success"
 			err := topUp.Update()
@@ -149,13 +207,13 @@ func EpayNotify(c *gin.Context) {
 			}
 			//user, _ := model.GetUserById(topUp.UserId, false)
 			//user.Quota += topUp.Amount * 500000
-			err = model.IncreaseUserQuota(topUp.UserId, topUp.Amount*500000)
+			err = model.IncreaseUserQuota(topUp.UserId, topUp.Amount*int(common.QuotaPerUnit))
 			if err != nil {
 				log.Printf("易支付回调更新用户失败: %v", topUp)
 				return
 			}
 			log.Printf("易支付回调更新用户成功 %v", topUp)
-			model.RecordLog(topUp.UserId, model.LogTypeTopup, fmt.Sprintf("使用在线充值成功，充值金额: %v，支付金额：%f", common.LogQuota(topUp.Amount*500000), topUp.Money))
+			model.RecordLog(topUp.UserId, model.LogTypeTopup, fmt.Sprintf("使用在线充值成功，充值金额: %v，支付金额：%f", common.LogQuota(topUp.Amount*int(common.QuotaPerUnit)), topUp.Money))
 		}
 	} else {
 		log.Printf("易支付异常回调: %v", verifyInfo)
@@ -169,12 +227,17 @@ func RequestAmount(c *gin.Context) {
 		c.JSON(200, gin.H{"message": "error", "data": "参数错误"})
 		return
 	}
-	if req.Amount < common.MinTopUp {
-		c.JSON(200, gin.H{"message": "error", "data": fmt.Sprintf("充值数量不能小于 %d", common.MinTopUp)})
+
+	if req.Amount < getMinTopup() {
+		c.JSON(200, gin.H{"message": "error", "data": fmt.Sprintf("充值数量不能小于 %d", getMinTopup())})
 		return
 	}
 	id := c.GetInt("id")
 	user, _ := model.GetUserById(id, false)
-	payMoney := GetAmount(float64(req.Amount), *user)
+	payMoney := getPayMoney(float64(req.Amount), *user)
+	if payMoney <= 0.01 {
+		c.JSON(200, gin.H{"message": "error", "data": "充值金额过低"})
+		return
+	}
 	c.JSON(200, gin.H{"message": "success", "data": strconv.FormatFloat(payMoney, 'f', 2, 64)})
 }
--- a/controller/user.go
+++ b/controller/user.go
@@ -7,6 +7,7 @@ import (
 	"one-api/common"
 	"one-api/model"
 	"strconv"
+	"sync"

 	"github.com/gin-contrib/sessions"
 	"github.com/gin-gonic/gin"
@@ -683,7 +684,7 @@ func ManageUser(c *gin.Context) {
 			})
 			return
 		}
-		if err := user.HardDelete(); err != nil {
+		if err := user.Delete(); err != nil {
 			c.JSON(http.StatusOK, gin.H{
 				"success": false,
 				"message": err.Error(),
@@ -724,7 +725,7 @@ func ManageUser(c *gin.Context) {
 		user.Role = common.RoleCommonUser
 	}

-	if err := user.Update(false); err != nil {
+	if err := user.UpdateAll(false); err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
 			"message": err.Error(),
@@ -789,7 +790,11 @@ type topUpRequest struct {
 	Key string `json:"key"`
 }

+var lock = sync.Mutex{}
+
 func TopUp(c *gin.Context) {
+	lock.Lock()
+	defer lock.Unlock()
 	req := topUpRequest{}
 	err := c.ShouldBindJSON(&req)
 	if err != nil {
--- a/dto/error.go
+++ b/dto/error.go
@@ -10,6 +10,7 @@ type OpenAIError struct {
 type OpenAIErrorWithStatusCode struct {
 	Error      OpenAIError `json:"error"`
 	StatusCode int         `json:"status_code"`
+	LocalError bool
 }

 type GeneralErrorResponse struct {
--- a/dto/midjourney.go
+++ b/dto/midjourney.go
@@ -1,7 +1,21 @@
 package dto

+//type SimpleMjRequest struct {
+//	Prompt   string `json:"prompt"`
+//	CustomId string `json:"customId"`
+//	Action   string `json:"action"`
+//	Content  string `json:"content"`
+//}
+
+type SwapFaceRequest struct {
+	SourceBase64 string `json:"sourceBase64"`
+	TargetBase64 string `json:"targetBase64"`
+}
+
 type MidjourneyRequest struct {
 	Prompt      string   `json:"prompt"`
+	CustomId    string   `json:"customId"`
+	BotType     string   `json:"botType"`
 	NotifyHook  string   `json:"notifyHook"`
 	Action      string   `json:"action"`
 	Index       int      `json:"index"`
@@ -9,6 +23,7 @@ type MidjourneyRequest struct {
 	TaskId      string   `json:"taskId"`
 	Base64Array []string `json:"base64Array"`
 	Content     string   `json:"content"`
+	MaskBase64  string   `json:"maskBase64"`
 }

 type MidjourneyResponse struct {
@@ -17,3 +32,64 @@ type MidjourneyResponse struct {
 	Properties  interface{} `json:"properties"`
 	Result      string      `json:"result"`
 }
+
+type MidjourneyResponseWithStatusCode struct {
+	StatusCode int `json:"statusCode"`
+	Response   MidjourneyResponse
+}
+
+type MidjourneyDto struct {
+	MjId        string      `json:"id"`
+	Action      string      `json:"action"`
+	CustomId    string      `json:"customId"`
+	BotType     string      `json:"botType"`
+	Prompt      string      `json:"prompt"`
+	PromptEn    string      `json:"promptEn"`
+	Description string      `json:"description"`
+	State       string      `json:"state"`
+	SubmitTime  int64       `json:"submitTime"`
+	StartTime   int64       `json:"startTime"`
+	FinishTime  int64       `json:"finishTime"`
+	ImageUrl    string      `json:"imageUrl"`
+	Status      string      `json:"status"`
+	Progress    string      `json:"progress"`
+	FailReason  string      `json:"failReason"`
+	Buttons     any         `json:"buttons"`
+	MaskBase64  string      `json:"maskBase64"`
+	Properties  *Properties `json:"properties"`
+}
+
+type MidjourneyStatus struct {
+	Status int `json:"status"`
+}
+type MidjourneyWithoutStatus struct {
+	Id          int    `json:"id"`
+	Code        int    `json:"code"`
+	UserId      int    `json:"user_id" gorm:"index"`
+	Action      string `json:"action"`
+	MjId        string `json:"mj_id" gorm:"index"`
+	Prompt      string `json:"prompt"`
+	PromptEn    string `json:"prompt_en"`
+	Description string `json:"description"`
+	State       string `json:"state"`
+	SubmitTime  int64  `json:"submit_time"`
+	StartTime   int64  `json:"start_time"`
+	FinishTime  int64  `json:"finish_time"`
+	ImageUrl    string `json:"image_url"`
+	Progress    string `json:"progress"`
+	FailReason  string `json:"fail_reason"`
+	ChannelId   int    `json:"channel_id"`
+}
+
+type ActionButton struct {
+	CustomId any `json:"customId"`
+	Emoji    any `json:"emoji"`
+	Label    any `json:"label"`
+	Type     any `json:"type"`
+	Style    any `json:"style"`
+}
+
+type Properties struct {
+	FinalPrompt   string `json:"finalPrompt"`
+	FinalZhPrompt string `json:"finalZhPrompt"`
+}
--- a/dto/sensitive.go
+++ b/dto/sensitive.go
@@ -0,0 +1,6 @@
+package dto
+
+type SensitiveResponse struct {
+	SensitiveWords []string `json:"sensitive_words"`
+	Content        string   `json:"content"`
+}
--- a/dto/text_request.go
+++ b/dto/text_request.go
@@ -14,6 +14,7 @@ type GeneralOpenAIRequest struct {
 	MaxTokens        uint            `json:"max_tokens,omitempty"`
 	Temperature      float64         `json:"temperature,omitempty"`
 	TopP             float64         `json:"top_p,omitempty"`
+	TopK             int             `json:"top_k,omitempty"`
 	Stop             any             `json:"stop,omitempty"`
 	N                int             `json:"n,omitempty"`
 	Input            any             `json:"input,omitempty"`
--- a/dto/text_response.go
+++ b/dto/text_response.go
@@ -1,11 +1,31 @@
 package dto

-type TextResponse struct {
-	Choices []OpenAITextResponseChoice `json:"choices"`
+type TextResponseWithError struct {
+	Id      string                        `json:"id"`
+	Object  string                        `json:"object"`
+	Created int64                         `json:"created"`
+	Choices []OpenAITextResponseChoice    `json:"choices"`
+	Data    []OpenAIEmbeddingResponseItem `json:"data"`
+	Model   string                        `json:"model"`
 	Usage   `json:"usage"`
 	Error   OpenAIError `json:"error"`
 }

+type SimpleResponse struct {
+	Usage   `json:"usage"`
+	Error   OpenAIError                `json:"error"`
+	Choices []OpenAITextResponseChoice `json:"choices"`
+}
+
+type TextResponse struct {
+	Id      string                     `json:"id"`
+	Object  string                     `json:"object"`
+	Created int64                      `json:"created"`
+	Model   string                     `json:"model"`
+	Choices []OpenAITextResponseChoice `json:"choices"`
+	Usage   `json:"usage"`
+}
+
 type OpenAITextResponseChoice struct {
 	Index        int `json:"index"`
 	Message      `json:"message"`
@@ -34,13 +54,29 @@ type OpenAIEmbeddingResponse struct {
 }

 type ChatCompletionsStreamResponseChoice struct {
-	Delta struct {
-		Content   string `json:"content"`
-		Role      string `json:"role,omitempty"`
-		ToolCalls any    `json:"tool_calls,omitempty"`
-	} `json:"delta"`
-	FinishReason *string `json:"finish_reason,omitempty"`
-	Index        int     `json:"index,omitempty"`
+	Delta        ChatCompletionsStreamResponseChoiceDelta `json:"delta"`
+	FinishReason *string                                  `json:"finish_reason,omitempty"`
+	Index        int                                      `json:"index,omitempty"`
+}
+
+type ChatCompletionsStreamResponseChoiceDelta struct {
+	Content   string     `json:"content"`
+	Role      string     `json:"role,omitempty"`
+	ToolCalls []ToolCall `json:"tool_calls,omitempty"`
+}
+
+type ToolCall struct {
+	// Index is not nil only in chat completion chunk object
+	Index    *int         `json:"index,omitempty"`
+	ID       string       `json:"id"`
+	Type     any          `json:"type"`
+	Function FunctionCall `json:"function"`
+}
+
+type FunctionCall struct {
+	Name string `json:"name,omitempty"`
+	// call function with arguments in JSON format
+	Arguments string `json:"arguments,omitempty"`
 }

 type ChatCompletionsStreamResponse struct {
--- a/go.mod
+++ b/go.mod
@@ -4,22 +4,28 @@ module one-api
 go 1.18

 require (
-	github.com/chai2010/webp v1.1.1
+	github.com/Calcium-Ion/go-epay v0.0.2
+	github.com/anknown/ahocorasick v0.0.0-20190904063843-d75dbd5169c0
+	github.com/aws/aws-sdk-go-v2 v1.26.1
+	github.com/aws/aws-sdk-go-v2/credentials v1.17.11
+	github.com/aws/aws-sdk-go-v2/service/bedrockruntime v1.7.4
 	github.com/gin-contrib/cors v1.4.0
 	github.com/gin-contrib/gzip v0.0.6
 	github.com/gin-contrib/sessions v0.0.5
 	github.com/gin-contrib/static v0.0.1
 	github.com/gin-gonic/gin v1.9.1
-	github.com/go-playground/validator/v10 v10.16.0
+	github.com/go-playground/validator/v10 v10.19.0
 	github.com/go-redis/redis/v8 v8.11.5
 	github.com/golang-jwt/jwt v3.2.2+incompatible
 	github.com/google/uuid v1.3.0
 	github.com/gorilla/websocket v1.5.0
+	github.com/jinzhu/copier v0.4.0
+	github.com/pkg/errors v0.9.1
 	github.com/pkoukk/tiktoken-go v0.1.6
-	github.com/samber/lo v1.38.1
+	github.com/samber/lo v1.39.0
 	github.com/shirou/gopsutil v3.21.11+incompatible
-	github.com/star-horizon/go-epay v0.0.0-20230204124159-fa2e2293fdc2
-	golang.org/x/crypto v0.17.0
+	golang.org/x/crypto v0.21.0
+	golang.org/x/image v0.15.0
 	gorm.io/driver/mysql v1.4.3
 	gorm.io/driver/postgres v1.5.2
 	gorm.io/driver/sqlite v1.4.3
@@ -27,12 +33,17 @@ require (
 )

 require (
+	github.com/anknown/darts v0.0.0-20151216065714-83ff685239e6 // indirect
+	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.2 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.5 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.5 // indirect
+	github.com/aws/smithy-go v1.20.2 // indirect
 	github.com/bytedance/sonic v1.9.1 // indirect
 	github.com/cespare/xxhash/v2 v2.1.2 // indirect
 	github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
 	github.com/dlclark/regexp2 v1.10.0 // indirect
-	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.3 // indirect
 	github.com/gin-contrib/sse v0.1.0 // indirect
 	github.com/go-ole/go-ole v1.2.6 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
@@ -50,7 +61,7 @@ require (
 	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.4 // indirect
-	github.com/leodido/go-urn v1.2.4 // indirect
+	github.com/leodido/go-urn v1.4.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-sqlite3 v2.0.3+incompatible // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
@@ -63,10 +74,10 @@ require (
 	github.com/ugorji/go/codec v1.2.11 // indirect
 	github.com/yusufpapurcu/wmi v1.2.3 // indirect
 	golang.org/x/arch v0.3.0 // indirect
-	golang.org/x/exp v0.0.0-20220303212507-bbda1eaf7a17 // indirect
-	golang.org/x/net v0.17.0 // indirect
-	golang.org/x/sync v0.1.0 // indirect
-	golang.org/x/sys v0.15.0 // indirect
+	golang.org/x/exp v0.0.0-20240404231335-c0f41cb1a7a0 // indirect
+	golang.org/x/net v0.21.0 // indirect
+	golang.org/x/sync v0.7.0 // indirect
+	golang.org/x/sys v0.18.0 // indirect
 	golang.org/x/text v0.14.0 // indirect
 	google.golang.org/protobuf v1.30.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
--- a/go.sum
+++ b/go.sum
@@ -1,10 +1,28 @@
+github.com/Calcium-Ion/go-epay v0.0.2 h1:3knFBuaBFpHzsGeGQU/QxUqZSHh5s0+jGo0P62pJzWc=
+github.com/Calcium-Ion/go-epay v0.0.2/go.mod h1:cxo/ZOg8ClvE3VAnCmEzbuyAZINSq7kFEN9oHj5WQ2U=
+github.com/anknown/ahocorasick v0.0.0-20190904063843-d75dbd5169c0 h1:onfun1RA+KcxaMk1lfrRnwCd1UUuOjJM/lri5eM1qMs=
+github.com/anknown/ahocorasick v0.0.0-20190904063843-d75dbd5169c0/go.mod h1:4yg+jNTYlDEzBjhGS96v+zjyA3lfXlFd5CiTLIkPBLI=
+github.com/anknown/darts v0.0.0-20151216065714-83ff685239e6 h1:HblK3eJHq54yET63qPCTJnks3loDse5xRmmqHgHzwoI=
+github.com/anknown/darts v0.0.0-20151216065714-83ff685239e6/go.mod h1:pbiaLIeYLUbgMY1kwEAdwO6UKD5ZNwdPGQlwokS9fe8=
+github.com/aws/aws-sdk-go-v2 v1.26.1 h1:5554eUqIYVWpU0YmeeYZ0wU64H2VLBs8TlhRB2L+EkA=
+github.com/aws/aws-sdk-go-v2 v1.26.1/go.mod h1:ffIFB97e2yNsv4aTSGkqtHnppsIJzw7G7BReUZ3jCXM=
+github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.2 h1:x6xsQXGSmW6frevwDA+vi/wqhp1ct18mVXYN08/93to=
+github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.2/go.mod h1:lPprDr1e6cJdyYeGXnRaJoP4Md+cDBvi2eOj00BlGmg=
+github.com/aws/aws-sdk-go-v2/credentials v1.17.11 h1:YuIB1dJNf1Re822rriUOTxopaHHvIq0l/pX3fwO+Tzs=
+github.com/aws/aws-sdk-go-v2/credentials v1.17.11/go.mod h1:AQtFPsDH9bI2O+71anW6EKL+NcD7LG3dpKGMV4SShgo=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.5 h1:aw39xVGeRWlWx9EzGVnhOR4yOjQDHPQ6o6NmBlscyQg=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.5/go.mod h1:FSaRudD0dXiMPK2UjknVwwTYyZMRsHv3TtkabsZih5I=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.5 h1:PG1F3OD1szkuQPzDw3CIQsRIrtTlUC3lP84taWzHlq0=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.5/go.mod h1:jU1li6RFryMz+so64PpKtudI+QzbKoIEivqdf6LNpOc=
+github.com/aws/aws-sdk-go-v2/service/bedrockruntime v1.7.4 h1:JgHnonzbnA3pbqj76wYsSZIZZQYBxkmMEjvL6GHy8XU=
+github.com/aws/aws-sdk-go-v2/service/bedrockruntime v1.7.4/go.mod h1:nZspkhg+9p8iApLFoyAqfyuMP0F38acy2Hm3r5r95Cg=
+github.com/aws/smithy-go v1.20.2 h1:tbp628ireGtzcHDDmLT/6ADHidqnwgF57XOXZe6tp4Q=
+github.com/aws/smithy-go v1.20.2/go.mod h1:krry+ya/rV9RDcV/Q16kpu6ypI4K2czasz0NC3qS14E=
 github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM=
 github.com/bytedance/sonic v1.9.1 h1:6iJ6NqdoxCDr6mbY8h18oSO+cShGSMRGCEo7F2h0x8s=
 github.com/bytedance/sonic v1.9.1/go.mod h1:i736AoUSYt75HyZLoJW9ERYxcy6eaN6h4BZXU064P/U=
 github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE=
 github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/chai2010/webp v1.1.1 h1:jTRmEccAJ4MGrhFOrPMpNGIJ/eybIgwKpcACsrTEapk=
-github.com/chai2010/webp v1.1.1/go.mod h1:0XVwvZWdjjdxpUEIf7b9g9VkHFnInUSYujwqTLEuldU=
 github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
 github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 h1:qSGYFH7+jGhDF8vLC+iwCD4WpbV1EBDSzWkJODFLams=
 github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
@@ -17,8 +35,8 @@ github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cu
 github.com/dlclark/regexp2 v1.10.0 h1:+/GIL799phkJqYW+3YbOd8LCcbHzT0Pbo8zl70MHsq0=
 github.com/dlclark/regexp2 v1.10.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
 github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
-github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU=
-github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA=
+github.com/gabriel-vasile/mimetype v1.4.3 h1:in2uUcidCuFcDKtdcBxlR0rJ1+fsokWf+uqxgUFjbI0=
+github.com/gabriel-vasile/mimetype v1.4.3/go.mod h1:d8uq/6HKRL6CGdk+aubisF/M5GcPfT7nKyLpA0lbSSk=
 github.com/gin-contrib/cors v1.4.0 h1:oJ6gwtUl3lqV0WEIwM/LxPF1QZ5qe2lGWdY2+bz7y0g=
 github.com/gin-contrib/cors v1.4.0/go.mod h1:bs9pNM0x/UsmHPBWT2xZz9ROh8xYjYkiURUfmBoMlcs=
 github.com/gin-contrib/gzip v0.0.6 h1:NjcunTcGAj5CO1gn4N8jHOSIeRFHIbn51z6K+xaN4d4=
@@ -47,10 +65,8 @@ github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJn
 github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
 github.com/go-playground/validator/v10 v10.2.0/go.mod h1:uOYAAleCW8F/7oMFd6aG0GOhaH6EGOAJShg8Id5JGkI=
 github.com/go-playground/validator/v10 v10.10.0/go.mod h1:74x4gJWsvQexRdW8Pn3dXSGrTK4nAUsbPlLADvpJkos=
-github.com/go-playground/validator/v10 v10.14.0 h1:vgvQWe3XCz3gIeFDm/HnTIbj6UGmg/+t63MyGU2n5js=
-github.com/go-playground/validator/v10 v10.14.0/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
-github.com/go-playground/validator/v10 v10.16.0 h1:x+plE831WK4vaKHO/jpgUGsvLKIqRRkz6M78GuJAfGE=
-github.com/go-playground/validator/v10 v10.16.0/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
+github.com/go-playground/validator/v10 v10.19.0 h1:ol+5Fu+cSq9JD7SoSqe04GMI92cbn0+wvQ3bZ8b/AU4=
+github.com/go-playground/validator/v10 v10.19.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
 github.com/go-redis/redis/v8 v8.11.5 h1:AcZZR7igkdvfVmQTPnu9WE37LRrO/YrBH5zWyjDC0oI=
 github.com/go-redis/redis/v8 v8.11.5/go.mod h1:gREzHqY1hg6oD9ngVRbLStwAWKhA0FEgq8Jd4h5lpwo=
 github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfCHuOE=
@@ -62,8 +78,8 @@ github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keL
 github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I=
 github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
 github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
@@ -79,12 +95,12 @@ github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsI
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
-github.com/jackc/pgx/v5 v5.3.1 h1:Fcr8QJ1ZeLi5zsPZqQeUZhNhxfkkKBOgJuYkJHoBOtU=
-github.com/jackc/pgx/v5 v5.3.1/go.mod h1:t3JDKnCBlYIc0ewLF0Q7B8MXmoIaBOZj/ic7iHozM/8=
 github.com/jackc/pgx/v5 v5.5.1 h1:5I9etrGkLrN+2XPCsi6XLlV5DITbSL/xBZdmAxFcXPI=
 github.com/jackc/pgx/v5 v5.5.1/go.mod h1:Ig06C2Vu0t5qXC60W8sqIthScaEnFvojjj9dSljmHRA=
 github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
 github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
+github.com/jinzhu/copier v0.4.0 h1:w3ciUoD19shMCRargcpm0cm91ytaBhDvuRpz1ODO/U8=
+github.com/jinzhu/copier v0.4.0/go.mod h1:DfbEm0FYsaqBcKcFuvmOZb218JkPGtvSHsKg8S8hyyg=
 github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
 github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
 github.com/jinzhu/now v1.1.4/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
@@ -106,12 +122,10 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
 github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY=
-github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
-github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
+github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
+github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
-github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
-github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-sqlite3 v1.14.15/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg=
@@ -132,6 +146,8 @@ github.com/pelletier/go-toml/v2 v2.0.1/go.mod h1:r9LEWfGN8R5k0VXJ+0BkIe7MYkRdwZO
 github.com/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZR9tGQ=
 github.com/pelletier/go-toml/v2 v2.0.8/go.mod h1:vuYfssBdrU2XDZ9bYydBu6t+6a6PYNcZljzZR9VXg+4=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkoukk/tiktoken-go v0.1.6 h1:JF0TlJzhTbrI30wCvFuiw6FzP2+/bR+FIxUdgEAcUsw=
 github.com/pkoukk/tiktoken-go v0.1.6/go.mod h1:9NiV+i9mJKGj1rYOT+njbv+ZwA/zJxYdewGl6qVatpg=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
@@ -139,12 +155,10 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
 github.com/rogpeppe/go-internal v1.8.0 h1:FCbCCtXNOY3UtUuHUYaghJg4y7Fd14rXifAYUAtL9R8=
 github.com/rogpeppe/go-internal v1.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6poM+XZ2dLUbcbE=
-github.com/samber/lo v1.38.1 h1:j2XEAqXKb09Am4ebOg31SpvzUTTs6EN3VfgeLUhPdXM=
-github.com/samber/lo v1.38.1/go.mod h1:+m/ZKRl6ClXCE2Lgf3MsQlWfh4bn1bz6CXEOxnEXnEA=
+github.com/samber/lo v1.39.0 h1:4gTz1wUhNYLhFSKl6O+8peW0v2F4BCY034GRpU9WnuA=
+github.com/samber/lo v1.39.0/go.mod h1:+m/ZKRl6ClXCE2Lgf3MsQlWfh4bn1bz6CXEOxnEXnEA=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=
 github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
-github.com/star-horizon/go-epay v0.0.0-20230204124159-fa2e2293fdc2 h1:avbt5a8F/zbYwFzTugrqWOBJe/K1cJj6+xpr+x1oVAI=
-github.com/star-horizon/go-epay v0.0.0-20230204124159-fa2e2293fdc2/go.mod h1:SiffGCWGGMVwujne2dUQbJ5zUVD1V1Yj0hDuTfqFNEo=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
@@ -155,9 +169,8 @@ github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY=
 github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU=
 github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI=
 github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk=
@@ -176,17 +189,17 @@ golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUu
 golang.org/x/arch v0.3.0 h1:02VY4/ZcO/gBOH6PUaoiptASxtXU10jazRCP865E97k=
 golang.org/x/arch v0.3.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
 golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.14.0 h1:wBqGXzWJW6m1XrIKlAH0Hs1JJ7+9KBwnIO8v66Q9cHc=
-golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf4=
-golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
-golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
-golang.org/x/exp v0.0.0-20220303212507-bbda1eaf7a17 h1:3MTrJm4PyNL9NBqvYDSj3DHl46qQakyfqfWo4jgfaEM=
-golang.org/x/exp v0.0.0-20220303212507-bbda1eaf7a17/go.mod h1:lgLbSvA5ygNOMpwM/9anMpWVlVJ7Z+cHWq/eFuinpGE=
+golang.org/x/crypto v0.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA=
+golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
+golang.org/x/exp v0.0.0-20240404231335-c0f41cb1a7a0 h1:985EYyeCOxTpcgOTJpflJUwOeEz0CQOdPt73OzpE9F8=
+golang.org/x/exp v0.0.0-20240404231335-c0f41cb1a7a0/go.mod h1:/lliqkxwWAhPjf5oSOIJup2XcqJaw8RGS6k3TGEc7GI=
+golang.org/x/image v0.15.0 h1:kOELfmgrmJlw4Cdb7g/QGuB3CvDrXbqEIww/pNtNBm8=
+golang.org/x/image v0.15.0/go.mod h1:HUYqC05R2ZcZ3ejNQsIHQDQiwWM4JBqmm6MKANTp4LE=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM=
-golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
-golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
+golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
+golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
+golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -197,21 +210,16 @@ golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE=
-golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc=
-golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4=
+golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
-golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng=
--- a/main.go
+++ b/main.go
@@ -20,10 +20,10 @@ import (
 	_ "net/http/pprof"
 )

-//go:embed web/build
+//go:embed web/dist
 var buildFS embed.FS

-//go:embed web/build/index.html
+//go:embed web/dist/index.html
 var indexPage []byte

 func main() {
--- a/2
+++ b/2
@@ -7,7 +7,7 @@ all: build-frontend start-backend

 build-frontend:
 	@echo "Building frontend..."
-	@cd $(FRONTEND_DIR) && npm install && DISABLE_ESLINT_PLUGIN='true' REACT_APP_VERSION=$(cat VERSION) npm run build npm run build
+	@cd $(FRONTEND_DIR) && npm install && DISABLE_ESLINT_PLUGIN='true' VITE_REACT_APP_VERSION=$(cat VERSION) npm run build

 start-backend:
 	@echo "Starting backend dev server..."
--- a/middleware/auth.go
+++ b/middleware/auth.go
@@ -100,16 +100,16 @@ func TokenAuth() func(c *gin.Context) {
 		}
 		token, err := model.ValidateUserToken(key)
 		if err != nil {
-			abortWithMessage(c, http.StatusUnauthorized, err.Error())
+			abortWithOpenAiMessage(c, http.StatusUnauthorized, err.Error())
 			return
 		}
 		userEnabled, err := model.CacheIsUserEnabled(token.UserId)
 		if err != nil {
-			abortWithMessage(c, http.StatusInternalServerError, err.Error())
+			abortWithOpenAiMessage(c, http.StatusInternalServerError, err.Error())
 			return
 		}
 		if !userEnabled {
-			abortWithMessage(c, http.StatusForbidden, "用户已被封禁")
+			abortWithOpenAiMessage(c, http.StatusForbidden, "用户已被封禁")
 			return
 		}
 		c.Set("id", token.UserId)
@@ -125,17 +125,11 @@ func TokenAuth() func(c *gin.Context) {
 		} else {
 			c.Set("token_model_limit_enabled", false)
 		}
-		requestURL := c.Request.URL.String()
-		consumeQuota := true
-		if strings.HasPrefix(requestURL, "/v1/models") {
-			consumeQuota = false
-		}
-		c.Set("consume_quota", consumeQuota)
 		if len(parts) > 1 {
 			if model.IsAdmin(token.UserId) {
-				c.Set("channelId", parts[1])
+				c.Set("specific_channel_id", parts[1])
 			} else {
-				abortWithMessage(c, http.StatusForbidden, "普通用户不支持指定渠道")
+				abortWithOpenAiMessage(c, http.StatusForbidden, "普通用户不支持指定渠道")
 				return
 			}
 		}
--- a/middleware/distributor.go
+++ b/middleware/distributor.go
@@ -4,7 +4,11 @@ import (
 	"fmt"
 	"net/http"
 	"one-api/common"
+	"one-api/constant"
+	"one-api/dto"
 	"one-api/model"
+	relayconstant "one-api/relay/constant"
+	"one-api/service"
 	"strconv"
 	"strings"

@@ -19,62 +23,27 @@ func Distribute() func(c *gin.Context) {
 	return func(c *gin.Context) {
 		userId := c.GetInt("id")
 		var channel *model.Channel
-		channelId, ok := c.Get("channelId")
+		channelId, ok := c.Get("specific_channel_id")
+		modelRequest, shouldSelectChannel, err := getModelRequest(c)
+		userGroup, _ := model.CacheGetUserGroup(userId)
+		c.Set("group", userGroup)
 		if ok {
 			id, err := strconv.Atoi(channelId.(string))
 			if err != nil {
-				abortWithMessage(c, http.StatusBadRequest, "无效的渠道 Id")
+				abortWithOpenAiMessage(c, http.StatusBadRequest, "无效的渠道 Id")
 				return
 			}
 			channel, err = model.GetChannelById(id, true)
 			if err != nil {
-				abortWithMessage(c, http.StatusBadRequest, "无效的渠道 Id")
+				abortWithOpenAiMessage(c, http.StatusBadRequest, "无效的渠道 Id")
 				return
 			}
 			if channel.Status != common.ChannelStatusEnabled {
-				abortWithMessage(c, http.StatusForbidden, "该渠道已被禁用")
+				abortWithOpenAiMessage(c, http.StatusForbidden, "该渠道已被禁用")
 				return
 			}
 		} else {
 			// Select a channel for the user
-			var modelRequest ModelRequest
-			var err error
-			if strings.HasPrefix(c.Request.URL.Path, "/mj") {
-				// Midjourney
-				if modelRequest.Model == "" {
-					modelRequest.Model = "midjourney"
-				}
-			} else if !strings.HasPrefix(c.Request.URL.Path, "/v1/audio/transcriptions") {
-				err = common.UnmarshalBodyReusable(c, &modelRequest)
-			}
-			if err != nil {
-				abortWithMessage(c, http.StatusBadRequest, "无效的请求, "+err.Error())
-				return
-			}
-			if strings.HasPrefix(c.Request.URL.Path, "/v1/moderations") {
-				if modelRequest.Model == "" {
-					modelRequest.Model = "text-moderation-stable"
-				}
-			}
-			if strings.HasSuffix(c.Request.URL.Path, "embeddings") {
-				if modelRequest.Model == "" {
-					modelRequest.Model = c.Param("model")
-				}
-			}
-			if strings.HasPrefix(c.Request.URL.Path, "/v1/images/generations") {
-				if modelRequest.Model == "" {
-					modelRequest.Model = "dall-e"
-				}
-			}
-			if strings.HasPrefix(c.Request.URL.Path, "/v1/audio") {
-				if modelRequest.Model == "" {
-					if strings.HasPrefix(c.Request.URL.Path, "/v1/audio/speech") {
-						modelRequest.Model = "tts-1"
-					} else {
-						modelRequest.Model = "whisper-1"
-					}
-				}
-			}
 			// check token model mapping
 			modelLimitEnable := c.GetBool("token_model_limit_enabled")
 			if modelLimitEnable {
@@ -87,61 +56,141 @@ func Distribute() func(c *gin.Context) {
 				}
 				if tokenModelLimit != nil {
 					if _, ok := tokenModelLimit[modelRequest.Model]; !ok {
-						abortWithMessage(c, http.StatusForbidden, "该令牌无权访问模型 "+modelRequest.Model)
+						abortWithOpenAiMessage(c, http.StatusForbidden, "该令牌无权访问模型 "+modelRequest.Model)
 						return
 					}
 				} else {
 					// token model limit is empty, all models are not allowed
-					abortWithMessage(c, http.StatusForbidden, "该令牌无权访问任何模型")
+					abortWithOpenAiMessage(c, http.StatusForbidden, "该令牌无权访问任何模型")
 					return
 				}
 			}

-			userGroup, _ := model.CacheGetUserGroup(userId)
-			c.Set("group", userGroup)
-
-			channel, err = model.CacheGetRandomSatisfiedChannel(userGroup, modelRequest.Model)
-			if err != nil {
-				message := fmt.Sprintf("当前分组 %s 下对于模型 %s 无可用渠道", userGroup, modelRequest.Model)
-				// 如果错误，但是渠道不为空，说明是数据库一致性问题
-				if channel != nil {
-					common.SysError(fmt.Sprintf("渠道不存在：%d", channel.Id))
-					message = "数据库一致性已被破坏，请联系管理员"
+			if shouldSelectChannel {
+				channel, err = model.CacheGetRandomSatisfiedChannel(userGroup, modelRequest.Model, 0)
+				if err != nil {
+					message := fmt.Sprintf("当前分组 %s 下对于模型 %s 无可用渠道", userGroup, modelRequest.Model)
+					// 如果错误，但是渠道不为空，说明是数据库一致性问题
+					if channel != nil {
+						common.SysError(fmt.Sprintf("渠道不存在：%d", channel.Id))
+						message = "数据库一致性已被破坏，请联系管理员"
+					}
+					// 如果错误，而且渠道为空，说明是没有可用渠道
+					abortWithOpenAiMessage(c, http.StatusServiceUnavailable, message)
+					return
+				}
+				if channel == nil {
+					abortWithOpenAiMessage(c, http.StatusServiceUnavailable, fmt.Sprintf("当前分组 %s 下对于模型 %s 无可用渠道（数据库一致性已被破坏）", userGroup, modelRequest.Model))
+					return
 				}
-				// 如果错误，而且渠道为空，说明是没有可用渠道
-				abortWithMessage(c, http.StatusServiceUnavailable, message)
-				return
-			}
-			if channel == nil {
-				abortWithMessage(c, http.StatusServiceUnavailable, fmt.Sprintf("当前分组 %s 下对于模型 %s 无可用渠道（数据库一致性已被破坏）", userGroup, modelRequest.Model))
-				return
 			}
 		}
-		c.Set("channel", channel.Type)
-		c.Set("channel_id", channel.Id)
-		c.Set("channel_name", channel.Name)
-		ban := true
-		// parse *int to bool
-		if channel.AutoBan != nil && *channel.AutoBan == 0 {
-			ban = false
-		}
-		c.Set("auto_ban", ban)
-		c.Set("model_mapping", channel.GetModelMapping())
-		c.Request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", channel.Key))
-		c.Set("base_url", channel.GetBaseURL())
-		// TODO: api_version统一
-		switch channel.Type {
-		case common.ChannelTypeAzure:
-			c.Set("api_version", channel.Other)
-		case common.ChannelTypeXunfei:
-			c.Set("api_version", channel.Other)
-		//case common.ChannelTypeAIProxyLibrary:
-		//	c.Set("library_id", channel.Other)
-		case common.ChannelTypeGemini:
-			c.Set("api_version", channel.Other)
-		case common.ChannelTypeAli:
-			c.Set("plugin", channel.Other)
-		}
+		SetupContextForSelectedChannel(c, channel, modelRequest.Model)
 		c.Next()
 	}
 }
+
+func getModelRequest(c *gin.Context) (*ModelRequest, bool, error) {
+	var modelRequest ModelRequest
+	shouldSelectChannel := true
+	var err error
+	if strings.Contains(c.Request.URL.Path, "/mj/") {
+		relayMode := relayconstant.Path2RelayModeMidjourney(c.Request.URL.Path)
+		if relayMode == relayconstant.RelayModeMidjourneyTaskFetch ||
+			relayMode == relayconstant.RelayModeMidjourneyTaskFetchByCondition ||
+			relayMode == relayconstant.RelayModeMidjourneyNotify ||
+			relayMode == relayconstant.RelayModeMidjourneyTaskImageSeed {
+			shouldSelectChannel = false
+		} else {
+			midjourneyRequest := dto.MidjourneyRequest{}
+			err = common.UnmarshalBodyReusable(c, &midjourneyRequest)
+			if err != nil {
+				abortWithMidjourneyMessage(c, http.StatusBadRequest, constant.MjErrorUnknown, "无效的请求, "+err.Error())
+				return nil, false, err
+			}
+			midjourneyModel, mjErr, success := service.GetMjRequestModel(relayMode, &midjourneyRequest)
+			if mjErr != nil {
+				abortWithMidjourneyMessage(c, http.StatusBadRequest, mjErr.Code, mjErr.Description)
+				return nil, false, fmt.Errorf(mjErr.Description)
+			}
+			if midjourneyModel == "" {
+				if !success {
+					abortWithMidjourneyMessage(c, http.StatusBadRequest, constant.MjErrorUnknown, "无效的请求, 无法解析模型")
+					return nil, false, fmt.Errorf("无效的请求, 无法解析模型")
+				} else {
+					// task fetch, task fetch by condition, notify
+					shouldSelectChannel = false
+				}
+			}
+			modelRequest.Model = midjourneyModel
+		}
+		c.Set("relay_mode", relayMode)
+	} else if !strings.HasPrefix(c.Request.URL.Path, "/v1/audio/transcriptions") {
+		err = common.UnmarshalBodyReusable(c, &modelRequest)
+	}
+	if err != nil {
+		abortWithOpenAiMessage(c, http.StatusBadRequest, "无效的请求, "+err.Error())
+		return nil, false, err
+	}
+	if strings.HasPrefix(c.Request.URL.Path, "/v1/moderations") {
+		if modelRequest.Model == "" {
+			modelRequest.Model = "text-moderation-stable"
+		}
+	}
+	if strings.HasSuffix(c.Request.URL.Path, "embeddings") {
+		if modelRequest.Model == "" {
+			modelRequest.Model = c.Param("model")
+		}
+	}
+	if strings.HasPrefix(c.Request.URL.Path, "/v1/images/generations") {
+		if modelRequest.Model == "" {
+			modelRequest.Model = "dall-e"
+		}
+	}
+	if strings.HasPrefix(c.Request.URL.Path, "/v1/audio") {
+		if modelRequest.Model == "" {
+			if strings.HasPrefix(c.Request.URL.Path, "/v1/audio/speech") {
+				modelRequest.Model = "tts-1"
+			} else {
+				modelRequest.Model = "whisper-1"
+			}
+		}
+	}
+	return &modelRequest, shouldSelectChannel, nil
+}
+
+func SetupContextForSelectedChannel(c *gin.Context, channel *model.Channel, modelName string) {
+	c.Set("original_model", modelName) // for retry
+	if channel == nil {
+		return
+	}
+	c.Set("channel", channel.Type)
+	c.Set("channel_id", channel.Id)
+	c.Set("channel_name", channel.Name)
+	ban := true
+	// parse *int to bool
+	if channel.AutoBan != nil && *channel.AutoBan == 0 {
+		ban = false
+	}
+	if nil != channel.OpenAIOrganization && "" != *channel.OpenAIOrganization {
+		c.Set("channel_organization", *channel.OpenAIOrganization)
+	}
+	c.Set("auto_ban", ban)
+	c.Set("model_mapping", channel.GetModelMapping())
+	c.Set("status_code_mapping", channel.GetStatusCodeMapping())
+	c.Request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", channel.Key))
+	c.Set("base_url", channel.GetBaseURL())
+	// TODO: api_version统一
+	switch channel.Type {
+	case common.ChannelTypeAzure:
+		c.Set("api_version", channel.Other)
+	case common.ChannelTypeXunfei:
+		c.Set("api_version", channel.Other)
+	//case common.ChannelTypeAIProxyLibrary:
+	//	c.Set("library_id", channel.Other)
+	case common.ChannelTypeGemini:
+		c.Set("api_version", channel.Other)
+	case common.ChannelTypeAli:
+		c.Set("plugin", channel.Other)
+	}
+}
--- a/middleware/utils.go
+++ b/middleware/utils.go
@@ -5,7 +5,7 @@ import (
 	"one-api/common"
 )

-func abortWithMessage(c *gin.Context, statusCode int, message string) {
+func abortWithOpenAiMessage(c *gin.Context, statusCode int, message string) {
 	c.JSON(statusCode, gin.H{
 		"error": gin.H{
 			"message": common.MessageWithRequestId(message, c.GetString(common.RequestIdKey)),
@@ -15,3 +15,13 @@ func abortWithMessage(c *gin.Context, statusCode int, message string) {
 	c.Abort()
 	common.LogError(c.Request.Context(), message)
 }
+
+func abortWithMidjourneyMessage(c *gin.Context, statusCode int, code int, description string) {
+	c.JSON(statusCode, gin.H{
+		"description": description,
+		"type":        "new_api_error",
+		"code":        code,
+	})
+	c.Abort()
+	common.LogError(c.Request.Context(), description)
+}
--- a/model/ability.go
+++ b/model/ability.go
@@ -3,6 +3,8 @@ package model
 import (
 	"errors"
 	"fmt"
+	"github.com/samber/lo"
+	"gorm.io/gorm"
 	"one-api/common"
 	"strings"
 )
@@ -27,8 +29,7 @@ func GetGroupModels(group string) []string {
 	return models
 }

-func GetRandomSatisfiedChannel(group string, model string) (*Channel, error) {
-	var abilities []Ability
+func getPriority(group string, model string, retry int) (int, error) {
 	groupCol := "`group`"
 	trueVal := "1"
 	if common.UsingPostgreSQL {
@@ -36,9 +37,55 @@ func GetRandomSatisfiedChannel(group string, model string) (*Channel, error) {
 		trueVal = "true"
 	}

-	var err error = nil
+	var priorities []int
+	err := DB.Model(&Ability{}).
+		Select("DISTINCT(priority)").
+		Where(groupCol+" = ? and model = ? and enabled = "+trueVal, group, model).
+		Order("priority DESC").              // 按优先级降序排序
+		Pluck("priority", &priorities).Error // Pluck用于将查询的结果直接扫描到一个切片中
+
+	if err != nil {
+		// 处理错误
+		return 0, err
+	}
+
+	// 确定要使用的优先级
+	var priorityToUse int
+	if retry >= len(priorities) {
+		// 如果重试次数大于优先级数，则使用最小的优先级
+		priorityToUse = priorities[len(priorities)-1]
+	} else {
+		priorityToUse = priorities[retry]
+	}
+	return priorityToUse, nil
+}
+
+func getChannelQuery(group string, model string, retry int) *gorm.DB {
+	groupCol := "`group`"
+	trueVal := "1"
+	if common.UsingPostgreSQL {
+		groupCol = `"group"`
+		trueVal = "true"
+	}
 	maxPrioritySubQuery := DB.Model(&Ability{}).Select("MAX(priority)").Where(groupCol+" = ? and model = ? and enabled = "+trueVal, group, model)
 	channelQuery := DB.Where(groupCol+" = ? and model = ? and enabled = "+trueVal+" and priority = (?)", group, model, maxPrioritySubQuery)
+	if retry != 0 {
+		priority, err := getPriority(group, model, retry)
+		if err != nil {
+			common.SysError(fmt.Sprintf("Get priority failed: %s", err.Error()))
+		} else {
+			channelQuery = DB.Where(groupCol+" = ? and model = ? and enabled = "+trueVal+" and priority = ?", group, model, priority)
+		}
+	}
+
+	return channelQuery
+}
+
+func GetRandomSatisfiedChannel(group string, model string, retry int) (*Channel, error) {
+	var abilities []Ability
+
+	var err error = nil
+	channelQuery := getChannelQuery(group, model, retry)
 	if common.UsingSQLite || common.UsingPostgreSQL {
 		err = channelQuery.Order("weight DESC").Find(&abilities).Error
 	} else {
@@ -52,21 +99,16 @@ func GetRandomSatisfiedChannel(group string, model string) (*Channel, error) {
 		// Randomly choose one
 		weightSum := uint(0)
 		for _, ability_ := range abilities {
-			weightSum += ability_.Weight
+			weightSum += ability_.Weight + 10
 		}
-		if weightSum == 0 {
-			// All weight is 0, randomly choose one
-			channel.Id = abilities[common.GetRandomInt(len(abilities))].ChannelId
-		} else {
-			// Randomly choose one
-			weight := common.GetRandomInt(int(weightSum))
-			for _, ability_ := range abilities {
-				weight -= int(ability_.Weight)
-				//log.Printf("weight: %d, ability weight: %d", weight, *ability_.Weight)
-				if weight <= 0 {
-					channel.Id = ability_.ChannelId
-					break
-				}
+		// Randomly choose one
+		weight := common.GetRandomInt(int(weightSum))
+		for _, ability_ := range abilities {
+			weight -= int(ability_.Weight) + 10
+			//log.Printf("weight: %d, ability weight: %d", weight, *ability_.Weight)
+			if weight <= 0 {
+				channel.Id = ability_.ChannelId
+				break
 			}
 		}
 	} else {
@@ -93,7 +135,16 @@ func (channel *Channel) AddAbilities() error {
 			abilities = append(abilities, ability)
 		}
 	}
-	return DB.Create(&abilities).Error
+	if len(abilities) == 0 {
+		return nil
+	}
+	for _, chunk := range lo.Chunk(abilities, 50) {
+		err := DB.Create(&chunk).Error
+		if err != nil {
+			return err
+		}
+	}
+	return nil
 }

 func (channel *Channel) DeleteAbilities() error {
@@ -147,7 +198,12 @@ func FixAbility() (int, error) {
 		return 0, err
 	}
 	var channels []Channel
-	err = DB.Where("id NOT IN (?)", abilityChannelIds).Find(&channels).Error
+
+	if len(abilityChannelIds) == 0 {
+		err = DB.Find(&channels).Error
+	} else {
+		err = DB.Where("id NOT IN (?)", abilityChannelIds).Find(&channels).Error
+	}
 	if err != nil {
 		return 0, err
 	}
--- a/model/cache.go
+++ b/model/cache.go
@@ -25,9 +25,6 @@ var token2UserId = make(map[string]int)
 var token2UserIdLock sync.RWMutex

 func cacheSetToken(token *Token) error {
-	if !common.RedisEnabled {
-		return token.SelectUpdate()
-	}
 	jsonBytes, err := json.Marshal(token)
 	if err != nil {
 		return err
@@ -168,7 +165,11 @@ func CacheUpdateUserQuota(id int) error {
 	if err != nil {
 		return err
 	}
-	err = common.RedisSet(fmt.Sprintf("user_quota:%d", id), fmt.Sprintf("%d", quota), time.Duration(UserId2QuotaCacheSeconds)*time.Second)
+	return cacheSetUserQuota(id, quota)
+}
+
+func cacheSetUserQuota(id int, quota int) error {
+	err := common.RedisSet(fmt.Sprintf("user_quota:%d", id), fmt.Sprintf("%d", quota), time.Duration(UserId2QuotaCacheSeconds)*time.Second)
 	return err
 }

@@ -265,14 +266,14 @@ func SyncChannelCache(frequency int) {
 	}
 }

-func CacheGetRandomSatisfiedChannel(group string, model string) (*Channel, error) {
+func CacheGetRandomSatisfiedChannel(group string, model string, retry int) (*Channel, error) {
 	if strings.HasPrefix(model, "gpt-4-gizmo") {
 		model = "gpt-4-gizmo-*"
 	}

 	// if memory cache is disabled, get channel directly from database
 	if !common.MemoryCacheEnabled {
-		return GetRandomSatisfiedChannel(group, model)
+		return GetRandomSatisfiedChannel(group, model, retry)
 	}
 	channelSyncLock.RLock()
 	defer channelSyncLock.RUnlock()
@@ -280,15 +281,27 @@ func CacheGetRandomSatisfiedChannel(group string, model string) (*Channel, error
 	if len(channels) == 0 {
 		return nil, errors.New("channel not found")
 	}
-	endIdx := len(channels)
-	// choose by priority
-	firstChannel := channels[0]
-	if firstChannel.GetPriority() > 0 {
-		for i := range channels {
-			if channels[i].GetPriority() != firstChannel.GetPriority() {
-				endIdx = i
-				break
-			}
+
+	uniquePriorities := make(map[int]bool)
+	for _, channel := range channels {
+		uniquePriorities[int(channel.GetPriority())] = true
+	}
+	var sortedUniquePriorities []int
+	for priority := range uniquePriorities {
+		sortedUniquePriorities = append(sortedUniquePriorities, priority)
+	}
+	sort.Sort(sort.Reverse(sort.IntSlice(sortedUniquePriorities)))
+
+	if retry >= len(uniquePriorities) {
+		retry = len(uniquePriorities) - 1
+	}
+	targetPriority := int64(sortedUniquePriorities[retry])
+
+	// get the priority for the given retry number
+	var targetChannels []*Channel
+	for _, channel := range channels {
+		if channel.GetPriority() == targetPriority {
+			targetChannels = append(targetChannels, channel)
 		}
 	}

@@ -296,20 +309,14 @@ func CacheGetRandomSatisfiedChannel(group string, model string) (*Channel, error
 	smoothingFactor := 10
 	// Calculate the total weight of all channels up to endIdx
 	totalWeight := 0
-	for _, channel := range channels[:endIdx] {
+	for _, channel := range targetChannels {
 		totalWeight += channel.GetWeight() + smoothingFactor
 	}
-
-	//if totalWeight == 0 {
-	//	// If all weights are 0, select a channel randomly
-	//	return channels[rand.Intn(endIdx)], nil
-	//}
-
 	// Generate a random value in the range [0, totalWeight)
 	randomWeight := rand.Intn(totalWeight)

 	// Find a channel based on its weight
-	for _, channel := range channels[:endIdx] {
+	for _, channel := range targetChannels {
 		randomWeight -= channel.GetWeight() + smoothingFactor
 		if randomWeight < 0 {
 			return channel, nil
--- a/model/channel.go
+++ b/model/channel.go
@@ -10,6 +10,7 @@ type Channel struct {
 	Type               int     `json:"type" gorm:"default:0"`
 	Key                string  `json:"key" gorm:"not null"`
 	OpenAIOrganization *string `json:"openai_organization"`
+	TestModel          *string `json:"test_model"`
 	Status             int     `json:"status" gorm:"default:1"`
 	Name               string  `json:"name" gorm:"index"`
 	Weight             *uint   `json:"weight" gorm:"default:0"`
@@ -24,8 +25,10 @@ type Channel struct {
 	Group              string  `json:"group" gorm:"type:varchar(64);default:'default'"`
 	UsedQuota          int64   `json:"used_quota" gorm:"bigint;default:0"`
 	ModelMapping       *string `json:"model_mapping" gorm:"type:varchar(1024);default:''"`
-	Priority           *int64  `json:"priority" gorm:"bigint;default:0"`
-	AutoBan            *int    `json:"auto_ban" gorm:"default:1"`
+	//MaxInputTokens     *int    `json:"max_input_tokens" gorm:"default:0"`
+	StatusCodeMapping *string `json:"status_code_mapping" gorm:"type:varchar(1024);default:''"`
+	Priority          *int64  `json:"priority" gorm:"bigint;default:0"`
+	AutoBan           *int    `json:"auto_ban" gorm:"default:1"`
 }

 func GetAllChannels(startIdx int, num int, selectAll bool, idSort bool) ([]*Channel, error) {
@@ -152,6 +155,13 @@ func (channel *Channel) GetModelMapping() string {
 	return *channel.ModelMapping
 }

+func (channel *Channel) GetStatusCodeMapping() string {
+	if channel.StatusCodeMapping == nil {
+		return ""
+	}
+	return *channel.StatusCodeMapping
+}
+
 func (channel *Channel) Insert() error {
 	var err error
 	err = DB.Create(channel).Error
--- a/model/main.go
+++ b/model/main.go
@@ -62,6 +62,7 @@ func chooseDB() (*gorm.DB, error) {
 				dsn += "?parseTime=true"
 			}
 		}
+		common.UsingMySQL = true
 		return gorm.Open(mysql.Open(dsn), &gorm.Config{
 			PrepareStmt: true, // precompile SQL
 		})
@@ -92,6 +93,12 @@ func InitDB() (err error) {
 		if !common.IsMasterNode {
 			return nil
 		}
+		if common.UsingMySQL {
+			_, _ = sqlDB.Exec("DROP INDEX idx_channels_key ON channels;")             // TODO: delete this line when most users have upgraded
+			_, _ = sqlDB.Exec("ALTER TABLE midjourneys MODIFY action VARCHAR(40);")   // TODO: delete this line when most users have upgraded
+			_, _ = sqlDB.Exec("ALTER TABLE midjourneys MODIFY progress VARCHAR(30);") // TODO: delete this line when most users have upgraded
+			_, _ = sqlDB.Exec("ALTER TABLE midjourneys MODIFY status VARCHAR(20);")   // TODO: delete this line when most users have upgraded
+		}
 		common.SysLog("database migration started")
 		err = db.AutoMigrate(&Channel{})
 		if err != nil {
--- a/model/midjourney.go
+++ b/model/midjourney.go
@@ -4,21 +4,23 @@ type Midjourney struct {
 	Id          int    `json:"id"`
 	Code        int    `json:"code"`
 	UserId      int    `json:"user_id" gorm:"index"`
-	Action      string `json:"action"`
+	Action      string `json:"action" gorm:"type:varchar(40);index"`
 	MjId        string `json:"mj_id" gorm:"index"`
 	Prompt      string `json:"prompt"`
 	PromptEn    string `json:"prompt_en"`
 	Description string `json:"description"`
 	State       string `json:"state"`
-	SubmitTime  int64  `json:"submit_time"`
-	StartTime   int64  `json:"start_time"`
-	FinishTime  int64  `json:"finish_time"`
+	SubmitTime  int64  `json:"submit_time" gorm:"index"`
+	StartTime   int64  `json:"start_time" gorm:"index"`
+	FinishTime  int64  `json:"finish_time" gorm:"index"`
 	ImageUrl    string `json:"image_url"`
-	Status      string `json:"status"`
-	Progress    string `json:"progress"`
+	Status      string `json:"status" gorm:"type:varchar(20);index"`
+	Progress    string `json:"progress" gorm:"type:varchar(30);index"`
 	FailReason  string `json:"fail_reason"`
 	ChannelId   int    `json:"channel_id"`
 	Quota       int    `json:"quota"`
+	Buttons     string `json:"buttons"`
+	Properties  string `json:"properties"`
 }

 // TaskQueryParams 用于包含所有搜索条件的结构体，可以根据需求添加更多字段
--- a/model/option.go
+++ b/model/option.go
@@ -2,6 +2,7 @@ package model

 import (
 	"one-api/common"
+	"one-api/constant"
 	"strconv"
 	"strings"
 	"time"
@@ -43,12 +44,14 @@ func InitOptionMap() {
 	common.OptionMap["DataExportEnabled"] = strconv.FormatBool(common.DataExportEnabled)
 	common.OptionMap["ChannelDisableThreshold"] = strconv.FormatFloat(common.ChannelDisableThreshold, 'f', -1, 64)
 	common.OptionMap["EmailDomainRestrictionEnabled"] = strconv.FormatBool(common.EmailDomainRestrictionEnabled)
+	common.OptionMap["EmailAliasRestrictionEnabled"] = strconv.FormatBool(common.EmailAliasRestrictionEnabled)
 	common.OptionMap["EmailDomainWhitelist"] = strings.Join(common.EmailDomainWhitelist, ",")
 	common.OptionMap["SMTPServer"] = ""
 	common.OptionMap["SMTPFrom"] = ""
 	common.OptionMap["SMTPPort"] = strconv.Itoa(common.SMTPPort)
 	common.OptionMap["SMTPAccount"] = ""
 	common.OptionMap["SMTPToken"] = ""
+	common.OptionMap["SMTPSSLEnabled"] = strconv.FormatBool(common.SMTPSSLEnabled)
 	common.OptionMap["Notice"] = ""
 	common.OptionMap["About"] = ""
 	common.OptionMap["HomePageContent"] = ""
@@ -60,8 +63,8 @@ func InitOptionMap() {
 	common.OptionMap["CustomCallbackAddress"] = ""
 	common.OptionMap["EpayId"] = ""
 	common.OptionMap["EpayKey"] = ""
-	common.OptionMap["Price"] = strconv.FormatFloat(common.Price, 'f', -1, 64)
-	common.OptionMap["MinTopUp"] = strconv.Itoa(common.MinTopUp)
+	common.OptionMap["Price"] = strconv.FormatFloat(constant.Price, 'f', -1, 64)
+	common.OptionMap["MinTopUp"] = strconv.Itoa(constant.MinTopUp)
 	common.OptionMap["TopupGroupRatio"] = common.TopupGroupRatio2JSONString()
 	common.OptionMap["GitHubClientId"] = ""
 	common.OptionMap["GitHubClientSecret"] = ""
@@ -88,6 +91,15 @@ func InitOptionMap() {
 	common.OptionMap["DataExportInterval"] = strconv.Itoa(common.DataExportInterval)
 	common.OptionMap["DataExportDefaultTime"] = common.DataExportDefaultTime
 	common.OptionMap["DefaultCollapseSidebar"] = strconv.FormatBool(common.DefaultCollapseSidebar)
+	common.OptionMap["MjNotifyEnabled"] = strconv.FormatBool(constant.MjNotifyEnabled)
+	common.OptionMap["MjModeClearEnabled"] = strconv.FormatBool(constant.MjModeClearEnabled)
+	common.OptionMap["MjForwardUrlEnabled"] = strconv.FormatBool(constant.MjForwardUrlEnabled)
+	common.OptionMap["CheckSensitiveEnabled"] = strconv.FormatBool(constant.CheckSensitiveEnabled)
+	common.OptionMap["CheckSensitiveOnPromptEnabled"] = strconv.FormatBool(constant.CheckSensitiveOnPromptEnabled)
+	//common.OptionMap["CheckSensitiveOnCompletionEnabled"] = strconv.FormatBool(constant.CheckSensitiveOnCompletionEnabled)
+	common.OptionMap["StopOnSensitiveEnabled"] = strconv.FormatBool(constant.StopOnSensitiveEnabled)
+	common.OptionMap["SensitiveWords"] = constant.SensitiveWordsToString()
+	common.OptionMap["StreamCacheQueueLength"] = strconv.Itoa(constant.StreamCacheQueueLength)

 	common.OptionMapRWMutex.Unlock()
 	loadOptionsFromDatabase()
@@ -165,6 +177,8 @@ func updateOptionMap(key string, value string) (err error) {
 			common.RegisterEnabled = boolValue
 		case "EmailDomainRestrictionEnabled":
 			common.EmailDomainRestrictionEnabled = boolValue
+		case "EmailAliasRestrictionEnabled":
+			common.EmailAliasRestrictionEnabled = boolValue
 		case "AutomaticDisableChannelEnabled":
 			common.AutomaticDisableChannelEnabled = boolValue
 		case "AutomaticEnableChannelEnabled":
@@ -181,6 +195,22 @@ func updateOptionMap(key string, value string) (err error) {
 			common.DataExportEnabled = boolValue
 		case "DefaultCollapseSidebar":
 			common.DefaultCollapseSidebar = boolValue
+		case "MjNotifyEnabled":
+			constant.MjNotifyEnabled = boolValue
+		case "MjModeClearEnabled":
+			constant.MjModeClearEnabled = boolValue
+		case "MjForwardUrlEnabled":
+			constant.MjForwardUrlEnabled = boolValue
+		case "CheckSensitiveEnabled":
+			constant.CheckSensitiveEnabled = boolValue
+		case "CheckSensitiveOnPromptEnabled":
+			constant.CheckSensitiveOnPromptEnabled = boolValue
+		//case "CheckSensitiveOnCompletionEnabled":
+		//	constant.CheckSensitiveOnCompletionEnabled = boolValue
+		case "StopOnSensitiveEnabled":
+			constant.StopOnSensitiveEnabled = boolValue
+		case "SMTPSSLEnabled":
+			common.SMTPSSLEnabled = boolValue
 		}
 	}
 	switch key {
@@ -200,17 +230,17 @@ func updateOptionMap(key string, value string) (err error) {
 	case "ServerAddress":
 		common.ServerAddress = value
 	case "PayAddress":
-		common.PayAddress = value
+		constant.PayAddress = value
 	case "CustomCallbackAddress":
-		common.CustomCallbackAddress = value
+		constant.CustomCallbackAddress = value
 	case "EpayId":
-		common.EpayId = value
+		constant.EpayId = value
 	case "EpayKey":
-		common.EpayKey = value
+		constant.EpayKey = value
 	case "Price":
-		common.Price, _ = strconv.ParseFloat(value, 64)
+		constant.Price, _ = strconv.ParseFloat(value, 64)
 	case "MinTopUp":
-		common.MinTopUp, _ = strconv.Atoi(value)
+		constant.MinTopUp, _ = strconv.Atoi(value)
 	case "TopupGroupRatio":
 		err = common.UpdateTopupGroupRatioByJSONString(value)
 	case "GitHubClientId":
@@ -269,6 +299,10 @@ func updateOptionMap(key string, value string) (err error) {
 		common.ChannelDisableThreshold, _ = strconv.ParseFloat(value, 64)
 	case "QuotaPerUnit":
 		common.QuotaPerUnit, _ = strconv.ParseFloat(value, 64)
+	case "SensitiveWords":
+		constant.SensitiveWordsFromString(value)
+	case "StreamCacheQueueLength":
+		constant.StreamCacheQueueLength, _ = strconv.Atoi(value)
 	}
 	return err
 }
--- a/model/redemption.go
+++ b/model/redemption.go
@@ -8,16 +8,17 @@ import (
 )

 type Redemption struct {
-	Id           int    `json:"id"`
-	UserId       int    `json:"user_id"`
-	Key          string `json:"key" gorm:"type:char(32);uniqueIndex"`
-	Status       int    `json:"status" gorm:"default:1"`
-	Name         string `json:"name" gorm:"index"`
-	Quota        int    `json:"quota" gorm:"default:100"`
-	CreatedTime  int64  `json:"created_time" gorm:"bigint"`
-	RedeemedTime int64  `json:"redeemed_time" gorm:"bigint"`
-	Count        int    `json:"count" gorm:"-:all"` // only for api request
-	UsedUserId   int    `json:"used_user_id"`
+	Id           int            `json:"id"`
+	UserId       int            `json:"user_id"`
+	Key          string         `json:"key" gorm:"type:char(32);uniqueIndex"`
+	Status       int            `json:"status" gorm:"default:1"`
+	Name         string         `json:"name" gorm:"index"`
+	Quota        int            `json:"quota" gorm:"default:100"`
+	CreatedTime  int64          `json:"created_time" gorm:"bigint"`
+	RedeemedTime int64          `json:"redeemed_time" gorm:"bigint"`
+	Count        int            `json:"count" gorm:"-:all"` // only for api request
+	UsedUserId   int            `json:"used_user_id"`
+	DeletedAt    gorm.DeletedAt `gorm:"index"`
 }

 func GetAllRedemptions(startIdx int, num int) ([]*Redemption, error) {
@@ -55,7 +56,7 @@ func Redeem(key string, userId int) (quota int, err error) {
 	if common.UsingPostgreSQL {
 		keyCol = `"key"`
 	}
-
+	common.RandomSleep()
 	err = DB.Transaction(func(tx *gorm.DB) error {
 		err := tx.Set("gorm:query_option", "FOR UPDATE").Where(keyCol+" = ?", key).First(redemption).Error
 		if err != nil {
--- a/model/token.go
+++ b/model/token.go
@@ -10,19 +10,20 @@ import (
 )

 type Token struct {
-	Id                 int    `json:"id"`
-	UserId             int    `json:"user_id"`
-	Key                string `json:"key" gorm:"type:char(48);uniqueIndex"`
-	Status             int    `json:"status" gorm:"default:1"`
-	Name               string `json:"name" gorm:"index" `
-	CreatedTime        int64  `json:"created_time" gorm:"bigint"`
-	AccessedTime       int64  `json:"accessed_time" gorm:"bigint"`
-	ExpiredTime        int64  `json:"expired_time" gorm:"bigint;default:-1"` // -1 means never expired
-	RemainQuota        int    `json:"remain_quota" gorm:"default:0"`
-	UnlimitedQuota     bool   `json:"unlimited_quota" gorm:"default:false"`
-	ModelLimitsEnabled bool   `json:"model_limits_enabled" gorm:"default:false"`
-	ModelLimits        string `json:"model_limits" gorm:"type:varchar(1024);default:''"`
-	UsedQuota          int    `json:"used_quota" gorm:"default:0"` // used quota
+	Id                 int            `json:"id"`
+	UserId             int            `json:"user_id"`
+	Key                string         `json:"key" gorm:"type:char(48);uniqueIndex"`
+	Status             int            `json:"status" gorm:"default:1"`
+	Name               string         `json:"name" gorm:"index" `
+	CreatedTime        int64          `json:"created_time" gorm:"bigint"`
+	AccessedTime       int64          `json:"accessed_time" gorm:"bigint"`
+	ExpiredTime        int64          `json:"expired_time" gorm:"bigint;default:-1"` // -1 means never expired
+	RemainQuota        int            `json:"remain_quota" gorm:"default:0"`
+	UnlimitedQuota     bool           `json:"unlimited_quota" gorm:"default:false"`
+	ModelLimitsEnabled bool           `json:"model_limits_enabled" gorm:"default:false"`
+	ModelLimits        string         `json:"model_limits" gorm:"type:varchar(1024);default:''"`
+	UsedQuota          int            `json:"used_quota" gorm:"default:0"` // used quota
+	DeletedAt          gorm.DeletedAt `gorm:"index"`
 }

 func GetAllUserTokens(userId int, startIdx int, num int) ([]*Token, error) {
@@ -101,6 +102,11 @@ func GetTokenById(id int) (*Token, error) {
 	token := Token{Id: id}
 	var err error = nil
 	err = DB.First(&token, "id = ?", id).Error
+	if err != nil {
+		if common.RedisEnabled {
+			go cacheSetToken(&token)
+		}
+	}
 	return &token, err
 }

--- a/model/user.go
+++ b/model/user.go
@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"one-api/common"
+	"strconv"
 	"strings"
 	"time"

@@ -72,8 +73,26 @@ func GetAllUsers(startIdx int, num int) (users []*User, err error) {
 	return users, err
 }

-func SearchUsers(keyword string) (users []*User, err error) {
-	err = DB.Omit("password").Where("id = ? or username LIKE ? or email LIKE ? or display_name LIKE ?", keyword, keyword+"%", keyword+"%", keyword+"%").Find(&users).Error
+func SearchUsers(keyword string) ([]*User, error) {
+	var users []*User
+	var err error
+
+	// 尝试将关键字转换为整数ID
+	keywordInt, err := strconv.Atoi(keyword)
+	if err == nil {
+		// 如果转换成功，按照ID搜索用户
+		err = DB.Unscoped().Omit("password").Where("id = ?", keywordInt).Find(&users).Error
+		if err != nil || len(users) > 0 {
+			// 如果依据ID找到用户或者发生错误，返回结果或错误
+			return users, err
+		}
+	}
+
+	// 如果ID转换失败或者没有找到用户，依据其他字段进行模糊搜索
+	err = DB.Unscoped().Omit("password").
+		Where("username LIKE ? OR email LIKE ? OR display_name LIKE ?", keyword+"%", keyword+"%", keyword+"%").
+		Find(&users).Error
+
 	return users, err
 }

@@ -210,6 +229,27 @@ func (user *User) Update(updatePassword bool) error {
 	if err == nil {
 		if common.RedisEnabled {
 			_ = common.RedisSet(fmt.Sprintf("user_group:%d", user.Id), user.Group, time.Duration(UserId2GroupCacheSeconds)*time.Second)
+			_ = common.RedisSet(fmt.Sprintf("user_quota:%d", user.Id), strconv.Itoa(user.Quota), time.Duration(UserId2QuotaCacheSeconds)*time.Second)
+		}
+	}
+	return err
+}
+
+func (user *User) UpdateAll(updatePassword bool) error {
+	var err error
+	if updatePassword {
+		user.Password, err = common.Password2Hash(user.Password)
+		if err != nil {
+			return err
+		}
+	}
+	newUser := *user
+	DB.First(&user, user.Id)
+	err = DB.Model(user).Select("*").Updates(newUser).Error
+	if err == nil {
+		if common.RedisEnabled {
+			_ = common.RedisSet(fmt.Sprintf("user_group:%d", user.Id), user.Group, time.Duration(UserId2GroupCacheSeconds)*time.Second)
+			_ = common.RedisSet(fmt.Sprintf("user_quota:%d", user.Id), strconv.Itoa(user.Quota), time.Duration(UserId2QuotaCacheSeconds)*time.Second)
 		}
 	}
 	return err
@@ -370,6 +410,11 @@ func ValidateAccessToken(token string) (user *User) {

 func GetUserQuota(id int) (quota int, err error) {
 	err = DB.Model(&User{}).Where("id = ?", id).Select("quota").Find(&quota).Error
+	if err != nil {
+		if common.RedisEnabled {
+			go cacheSetUserQuota(id, quota)
+		}
+	}
 	return quota, err
 }

--- a/relay/channel/ali/dto.go
+++ b/relay/channel/ali/dto.go
@@ -6,8 +6,9 @@ type AliMessage struct {
 }

 type AliInput struct {
-	Prompt  string       `json:"prompt"`
-	History []AliMessage `json:"history"`
+	Prompt string `json:"prompt,omitempty"`
+	//History []AliMessage `json:"history,omitempty"`
+	Messages []AliMessage `json:"messages"`
 }

 type AliParameters struct {
@@ -20,7 +21,7 @@ type AliParameters struct {

 type AliChatRequest struct {
 	Model      string        `json:"model"`
-	Input      AliInput      `json:"input"`
+	Input      AliInput      `json:"input,omitempty"`
 	Parameters AliParameters `json:"parameters,omitempty"`
 }

--- a/relay/channel/ali/relay-ali.go
+++ b/relay/channel/ali/relay-ali.go
@@ -18,7 +18,7 @@ const EnableSearchModelSuffix = "-internet"

 func requestOpenAI2Ali(request dto.GeneralOpenAIRequest) *AliChatRequest {
 	messages := make([]AliMessage, 0, len(request.Messages))
-	prompt := ""
+	//prompt := ""
 	for i := 0; i < len(request.Messages); i++ {
 		message := request.Messages[i]
 		messages = append(messages, AliMessage{
@@ -35,8 +35,8 @@ func requestOpenAI2Ali(request dto.GeneralOpenAIRequest) *AliChatRequest {
 	return &AliChatRequest{
 		Model: request.Model,
 		Input: AliInput{
-			Prompt:  prompt,
-			History: messages,
+			//Prompt:  prompt,
+			Messages: messages,
 		},
 		Parameters: AliParameters{
 			IncrementalOutput: request.Stream,
--- a/relay/channel/aws/adaptor.go
+++ b/relay/channel/aws/adaptor.go
@@ -0,0 +1,79 @@
+package aws
+
+import (
+	"errors"
+	"github.com/gin-gonic/gin"
+	"io"
+	"net/http"
+	"one-api/dto"
+	"one-api/relay/channel/claude"
+	relaycommon "one-api/relay/common"
+	"strings"
+)
+
+const (
+	RequestModeCompletion = 1
+	RequestModeMessage    = 2
+)
+
+type Adaptor struct {
+	RequestMode int
+}
+
+func (a *Adaptor) Init(info *relaycommon.RelayInfo, request dto.GeneralOpenAIRequest) {
+	if strings.HasPrefix(info.UpstreamModelName, "claude-3") {
+		a.RequestMode = RequestModeMessage
+	} else {
+		a.RequestMode = RequestModeCompletion
+	}
+}
+
+func (a *Adaptor) GetRequestURL(info *relaycommon.RelayInfo) (string, error) {
+	return "", nil
+}
+
+func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Request, info *relaycommon.RelayInfo) error {
+	return nil
+}
+
+func (a *Adaptor) ConvertRequest(c *gin.Context, relayMode int, request *dto.GeneralOpenAIRequest) (any, error) {
+	if request == nil {
+		return nil, errors.New("request is nil")
+	}
+
+	var claudeReq *claude.ClaudeRequest
+	var err error
+	if a.RequestMode == RequestModeCompletion {
+		claudeReq = claude.RequestOpenAI2ClaudeComplete(*request)
+	} else {
+		claudeReq, err = claude.RequestOpenAI2ClaudeMessage(*request)
+	}
+	c.Set("request_model", request.Model)
+	c.Set("converted_request", claudeReq)
+	return claudeReq, err
+}
+
+func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, requestBody io.Reader) (*http.Response, error) {
+	return nil, nil
+}
+
+func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo) (usage *dto.Usage, err *dto.OpenAIErrorWithStatusCode) {
+	if info.IsStream {
+		err, usage = awsStreamHandler(c, info, a.RequestMode)
+	} else {
+		err, usage = awsHandler(c, info, a.RequestMode)
+	}
+	return
+}
+
+func (a *Adaptor) GetModelList() (models []string) {
+	for n := range awsModelIDMap {
+		models = append(models, n)
+	}
+
+	return
+}
+
+func (a *Adaptor) GetChannelName() string {
+	return ChannelName
+}
--- a/relay/channel/aws/constants.go
+++ b/relay/channel/aws/constants.go
@@ -0,0 +1,12 @@
+package aws
+
+var awsModelIDMap = map[string]string{
+	"claude-instant-1.2":       "anthropic.claude-instant-v1",
+	"claude-2.0":               "anthropic.claude-v2",
+	"claude-2.1":               "anthropic.claude-v2:1",
+	"claude-3-sonnet-20240229": "anthropic.claude-3-sonnet-20240229-v1:0",
+	"claude-3-opus-20240229":   "anthropic.claude-3-opus-20240229-v1:0",
+	"claude-3-haiku-20240307":  "anthropic.claude-3-haiku-20240307-v1:0",
+}
+
+var ChannelName = "aws"
--- a/relay/channel/aws/dto.go
+++ b/relay/channel/aws/dto.go
@@ -0,0 +1,14 @@
+package aws
+
+import "one-api/relay/channel/claude"
+
+type AwsClaudeRequest struct {
+	// AnthropicVersion should be "bedrock-2023-05-31"
+	AnthropicVersion string                 `json:"anthropic_version"`
+	Messages         []claude.ClaudeMessage `json:"messages"`
+	MaxTokens        int                    `json:"max_tokens,omitempty"`
+	Temperature      float64                `json:"temperature,omitempty"`
+	TopP             float64                `json:"top_p,omitempty"`
+	TopK             int                    `json:"top_k,omitempty"`
+	StopSequences    []string               `json:"stop_sequences,omitempty"`
+}
--- a/relay/channel/aws/relay-aws.go
+++ b/relay/channel/aws/relay-aws.go
@@ -0,0 +1,211 @@
+package aws
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+	"io"
+	"net/http"
+	"one-api/common"
+	relaymodel "one-api/dto"
+	"one-api/relay/channel/claude"
+	relaycommon "one-api/relay/common"
+	"strings"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/credentials"
+	"github.com/aws/aws-sdk-go-v2/service/bedrockruntime"
+	"github.com/aws/aws-sdk-go-v2/service/bedrockruntime/types"
+)
+
+func newAwsClient(c *gin.Context, info *relaycommon.RelayInfo) (*bedrockruntime.Client, error) {
+	awsSecret := strings.Split(info.ApiKey, "|")
+	if len(awsSecret) != 3 {
+		return nil, errors.New("invalid aws secret key")
+	}
+	ak := awsSecret[0]
+	sk := awsSecret[1]
+	region := awsSecret[2]
+	client := bedrockruntime.New(bedrockruntime.Options{
+		Region:      region,
+		Credentials: aws.NewCredentialsCache(credentials.NewStaticCredentialsProvider(ak, sk, "")),
+	})
+
+	return client, nil
+}
+
+func wrapErr(err error) *relaymodel.OpenAIErrorWithStatusCode {
+	return &relaymodel.OpenAIErrorWithStatusCode{
+		StatusCode: http.StatusInternalServerError,
+		Error: relaymodel.OpenAIError{
+			Message: fmt.Sprintf("%s", err.Error()),
+		},
+	}
+}
+
+func awsModelID(requestModel string) (string, error) {
+	if awsModelID, ok := awsModelIDMap[requestModel]; ok {
+		return awsModelID, nil
+	}
+
+	return "", errors.Errorf("model %s not found", requestModel)
+}
+
+func awsHandler(c *gin.Context, info *relaycommon.RelayInfo, requestMode int) (*relaymodel.OpenAIErrorWithStatusCode, *relaymodel.Usage) {
+	awsCli, err := newAwsClient(c, info)
+	if err != nil {
+		return wrapErr(errors.Wrap(err, "newAwsClient")), nil
+	}
+
+	awsModelId, err := awsModelID(c.GetString("request_model"))
+	if err != nil {
+		return wrapErr(errors.Wrap(err, "awsModelID")), nil
+	}
+
+	awsReq := &bedrockruntime.InvokeModelInput{
+		ModelId:     aws.String(awsModelId),
+		Accept:      aws.String("application/json"),
+		ContentType: aws.String("application/json"),
+	}
+
+	claudeReq_, ok := c.Get("converted_request")
+	if !ok {
+		return wrapErr(errors.New("request not found")), nil
+	}
+	claudeReq := claudeReq_.(*claude.ClaudeRequest)
+	awsClaudeReq := &AwsClaudeRequest{
+		AnthropicVersion: "bedrock-2023-05-31",
+	}
+	if err = copier.Copy(awsClaudeReq, claudeReq); err != nil {
+		return wrapErr(errors.Wrap(err, "copy request")), nil
+	}
+
+	awsReq.Body, err = json.Marshal(awsClaudeReq)
+	if err != nil {
+		return wrapErr(errors.Wrap(err, "marshal request")), nil
+	}
+
+	awsResp, err := awsCli.InvokeModel(c.Request.Context(), awsReq)
+	if err != nil {
+		return wrapErr(errors.Wrap(err, "InvokeModel")), nil
+	}
+
+	claudeResponse := new(claude.ClaudeResponse)
+	err = json.Unmarshal(awsResp.Body, claudeResponse)
+	if err != nil {
+		return wrapErr(errors.Wrap(err, "unmarshal response")), nil
+	}
+
+	openaiResp := claude.ResponseClaude2OpenAI(requestMode, claudeResponse)
+	usage := relaymodel.Usage{
+		PromptTokens:     claudeResponse.Usage.InputTokens,
+		CompletionTokens: claudeResponse.Usage.OutputTokens,
+		TotalTokens:      claudeResponse.Usage.InputTokens + claudeResponse.Usage.OutputTokens,
+	}
+	openaiResp.Usage = usage
+
+	c.JSON(http.StatusOK, openaiResp)
+	return nil, &usage
+}
+
+func awsStreamHandler(c *gin.Context, info *relaycommon.RelayInfo, requestMode int) (*relaymodel.OpenAIErrorWithStatusCode, *relaymodel.Usage) {
+	awsCli, err := newAwsClient(c, info)
+	if err != nil {
+		return wrapErr(errors.Wrap(err, "newAwsClient")), nil
+	}
+
+	awsModelId, err := awsModelID(c.GetString("request_model"))
+	if err != nil {
+		return wrapErr(errors.Wrap(err, "awsModelID")), nil
+	}
+
+	awsReq := &bedrockruntime.InvokeModelWithResponseStreamInput{
+		ModelId:     aws.String(awsModelId),
+		Accept:      aws.String("application/json"),
+		ContentType: aws.String("application/json"),
+	}
+
+	claudeReq_, ok := c.Get("converted_request")
+	if !ok {
+		return wrapErr(errors.New("request not found")), nil
+	}
+	claudeReq := claudeReq_.(*claude.ClaudeRequest)
+
+	awsClaudeReq := &AwsClaudeRequest{
+		AnthropicVersion: "bedrock-2023-05-31",
+	}
+	if err = copier.Copy(awsClaudeReq, claudeReq); err != nil {
+		return wrapErr(errors.Wrap(err, "copy request")), nil
+	}
+	awsReq.Body, err = json.Marshal(awsClaudeReq)
+	if err != nil {
+		return wrapErr(errors.Wrap(err, "marshal request")), nil
+	}
+
+	awsResp, err := awsCli.InvokeModelWithResponseStream(c.Request.Context(), awsReq)
+	if err != nil {
+		return wrapErr(errors.Wrap(err, "InvokeModelWithResponseStream")), nil
+	}
+	stream := awsResp.GetStream()
+	defer stream.Close()
+
+	c.Writer.Header().Set("Content-Type", "text/event-stream")
+	var usage relaymodel.Usage
+	var id string
+	var model string
+	c.Stream(func(w io.Writer) bool {
+		event, ok := <-stream.Events()
+		if !ok {
+			c.Render(-1, common.CustomEvent{Data: "data: [DONE]"})
+			return false
+		}
+
+		switch v := event.(type) {
+		case *types.ResponseStreamMemberChunk:
+			claudeResp := new(claude.ClaudeResponse)
+			err := json.NewDecoder(bytes.NewReader(v.Value.Bytes)).Decode(claudeResp)
+			if err != nil {
+				common.SysError("error unmarshalling stream response: " + err.Error())
+				return false
+			}
+
+			response, claudeUsage := claude.StreamResponseClaude2OpenAI(requestMode, claudeResp)
+			if claudeUsage != nil {
+				usage.PromptTokens += claudeUsage.InputTokens
+				usage.CompletionTokens += claudeUsage.OutputTokens
+			}
+
+			if response == nil {
+				return true
+			}
+
+			if response.Id != "" {
+				id = response.Id
+			}
+			if response.Model != "" {
+				model = response.Model
+			}
+			response.Id = id
+			response.Model = model
+
+			jsonStr, err := json.Marshal(response)
+			if err != nil {
+				common.SysError("error marshalling stream response: " + err.Error())
+				return true
+			}
+			c.Render(-1, common.CustomEvent{Data: "data: " + string(jsonStr)})
+			return true
+		case *types.UnknownUnionMember:
+			fmt.Println("unknown tag:", v.Tag)
+			return false
+		default:
+			fmt.Println("union is nil or unknown type")
+			return false
+		}
+	})
+
+	return nil, &usage
+}
--- a/relay/channel/claude/adaptor.go
+++ b/relay/channel/claude/adaptor.go
@@ -53,9 +53,9 @@ func (a *Adaptor) ConvertRequest(c *gin.Context, relayMode int, request *dto.Gen
 		return nil, errors.New("request is nil")
 	}
 	if a.RequestMode == RequestModeCompletion {
-		return requestOpenAI2ClaudeComplete(*request), nil
+		return RequestOpenAI2ClaudeComplete(*request), nil
 	} else {
-		return requestOpenAI2ClaudeMessage(*request)
+		return RequestOpenAI2ClaudeMessage(*request)
 	}
 }

--- a/relay/channel/claude/constants.go
+++ b/relay/channel/claude/constants.go
@@ -1,7 +1,13 @@
 package claude

 var ModelList = []string{
-	"claude-instant-1.2", "claude-2", "claude-2.0", "claude-2.1", "claude-3-sonnet-20240229", "claude-3-opus-20240229",
+	"claude-instant-1.2",
+	"claude-2",
+	"claude-2.0",
+	"claude-2.1",
+	"claude-3-sonnet-20240229",
+	"claude-3-opus-20240229",
+	"claude-3-haiku-20240307",
 }

 var ChannelName = "claude"
--- a/relay/channel/claude/relay-claude.go
+++ b/relay/channel/claude/relay-claude.go
@@ -26,7 +26,7 @@ func stopReasonClaude2OpenAI(reason string) string {
 	}
 }

-func requestOpenAI2ClaudeComplete(textRequest dto.GeneralOpenAIRequest) *ClaudeRequest {
+func RequestOpenAI2ClaudeComplete(textRequest dto.GeneralOpenAIRequest) *ClaudeRequest {
 	claudeRequest := ClaudeRequest{
 		Model:             textRequest.Model,
 		Prompt:            "",
@@ -34,6 +34,7 @@ func requestOpenAI2ClaudeComplete(textRequest dto.GeneralOpenAIRequest) *ClaudeR
 		StopSequences:     nil,
 		Temperature:       textRequest.Temperature,
 		TopP:              textRequest.TopP,
+		TopK:              textRequest.TopK,
 		Stream:            textRequest.Stream,
 	}
 	if claudeRequest.MaxTokensToSample == 0 {
@@ -56,13 +57,14 @@ func requestOpenAI2ClaudeComplete(textRequest dto.GeneralOpenAIRequest) *ClaudeR
 	return &claudeRequest
 }

-func requestOpenAI2ClaudeMessage(textRequest dto.GeneralOpenAIRequest) (*ClaudeRequest, error) {
+func RequestOpenAI2ClaudeMessage(textRequest dto.GeneralOpenAIRequest) (*ClaudeRequest, error) {
 	claudeRequest := ClaudeRequest{
 		Model:         textRequest.Model,
 		MaxTokens:     textRequest.MaxTokens,
 		StopSequences: nil,
 		Temperature:   textRequest.Temperature,
 		TopP:          textRequest.TopP,
+		TopK:          textRequest.TopK,
 		Stream:        textRequest.Stream,
 	}
 	if claudeRequest.MaxTokens == 0 {
@@ -120,7 +122,7 @@ func requestOpenAI2ClaudeMessage(textRequest dto.GeneralOpenAIRequest) (*ClaudeR
 	return &claudeRequest, nil
 }

-func streamResponseClaude2OpenAI(reqMode int, claudeResponse *ClaudeResponse) (*dto.ChatCompletionsStreamResponse, *ClaudeUsage) {
+func StreamResponseClaude2OpenAI(reqMode int, claudeResponse *ClaudeResponse) (*dto.ChatCompletionsStreamResponse, *ClaudeUsage) {
 	var response dto.ChatCompletionsStreamResponse
 	var claudeUsage *ClaudeUsage
 	response.Object = "chat.completion.chunk"
@@ -147,13 +149,18 @@ func streamResponseClaude2OpenAI(reqMode int, claudeResponse *ClaudeResponse) (*
 				choice.FinishReason = &finishReason
 			}
 			claudeUsage = &claudeResponse.Usage
+		} else if claudeResponse.Type == "message_stop" {
+			return nil, nil
 		}
 	}
+	if claudeUsage == nil {
+		claudeUsage = &ClaudeUsage{}
+	}
 	response.Choices = append(response.Choices, choice)
 	return &response, claudeUsage
 }

-func responseClaude2OpenAI(reqMode int, claudeResponse *ClaudeResponse) *dto.OpenAITextResponse {
+func ResponseClaude2OpenAI(reqMode int, claudeResponse *ClaudeResponse) *dto.OpenAITextResponse {
 	choices := make([]dto.OpenAITextResponseChoice, 0)
 	fullTextResponse := dto.OpenAITextResponse{
 		Id:      fmt.Sprintf("chatcmpl-%s", common.GetUUID()),
@@ -194,7 +201,8 @@ func responseClaude2OpenAI(reqMode int, claudeResponse *ClaudeResponse) *dto.Ope

 func claudeStreamHandler(requestMode int, modelName string, promptTokens int, c *gin.Context, resp *http.Response) (*dto.OpenAIErrorWithStatusCode, *dto.Usage) {
 	responseId := fmt.Sprintf("chatcmpl-%s", common.GetUUID())
-	var usage dto.Usage
+	var usage *dto.Usage
+	usage = &dto.Usage{}
 	responseText := ""
 	createdTime := common.GetTimestamp()
 	scanner := bufio.NewScanner(resp.Body)
@@ -236,7 +244,10 @@ func claudeStreamHandler(requestMode int, modelName string, promptTokens int, c
 				return true
 			}

-			response, claudeUsage := streamResponseClaude2OpenAI(requestMode, &claudeResponse)
+			response, claudeUsage := StreamResponseClaude2OpenAI(requestMode, &claudeResponse)
+			if response == nil {
+				return true
+			}
 			if requestMode == RequestModeCompletion {
 				responseText += claudeResponse.Completion
 				responseId = response.Id
@@ -277,9 +288,13 @@ func claudeStreamHandler(requestMode int, modelName string, promptTokens int, c
 		return service.OpenAIErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
 	}
 	if requestMode == RequestModeCompletion {
-		usage = *service.ResponseText2Usage(responseText, modelName, promptTokens)
+		usage, _ = service.ResponseText2Usage(responseText, modelName, promptTokens)
+	} else {
+		if usage.CompletionTokens == 0 {
+			usage, _ = service.ResponseText2Usage(responseText, modelName, usage.PromptTokens)
+		}
 	}
-	return nil, &usage
+	return nil, usage
 }

 func claudeHandler(requestMode int, c *gin.Context, resp *http.Response, promptTokens int, model string) (*dto.OpenAIErrorWithStatusCode, *dto.Usage) {
@@ -307,8 +322,11 @@ func claudeHandler(requestMode int, c *gin.Context, resp *http.Response, promptT
 			StatusCode: resp.StatusCode,
 		}, nil
 	}
-	fullTextResponse := responseClaude2OpenAI(requestMode, &claudeResponse)
-	completionTokens := service.CountTokenText(claudeResponse.Completion, model)
+	fullTextResponse := ResponseClaude2OpenAI(requestMode, &claudeResponse)
+	completionTokens, err, _ := service.CountTokenText(claudeResponse.Completion, model, false)
+	if err != nil {
+		return service.OpenAIErrorWrapper(err, "count_token_text_failed", http.StatusInternalServerError), nil
+	}
 	usage := dto.Usage{}
 	if requestMode == RequestModeCompletion {
 		usage.PromptTokens = promptTokens
--- a/relay/channel/gemini/adaptor.go
+++ b/relay/channel/gemini/adaptor.go
@@ -18,16 +18,28 @@ type Adaptor struct {
 func (a *Adaptor) Init(info *relaycommon.RelayInfo, request dto.GeneralOpenAIRequest) {
 }

+// 定义一个映射，存储模型名称和对应的版本
+var modelVersionMap = map[string]string{
+    "gemini-1.5-pro-latest": "v1beta",
+    "gemini-ultra":   "v1beta",
+}
+
 func (a *Adaptor) GetRequestURL(info *relaycommon.RelayInfo) (string, error) {
-	version := "v1"
-	if info.ApiVersion != "" {
-		version = info.ApiVersion
-	}
-	action := "generateContent"
-	if info.IsStream {
-		action = "streamGenerateContent"
-	}
-	return fmt.Sprintf("%s/%s/models/%s:%s", info.BaseUrl, version, info.UpstreamModelName, action), nil
+    // 从映射中获取模型名称对应的版本，如果找不到就使用 info.ApiVersion 或默认的版本 "v1"
+    version, beta := modelVersionMap[info.UpstreamModelName]
+    if !beta {
+        if info.ApiVersion != "" {
+            version = info.ApiVersion
+        } else {
+            version = "v1"
+        }
+    }
+
+    action := "generateContent"
+    if info.IsStream {
+        action = "streamGenerateContent"
+    }
+    return fmt.Sprintf("%s/%s/models/%s:%s", info.BaseUrl, version, info.UpstreamModelName, action), nil
 }

 func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Request, info *relaycommon.RelayInfo) error {
@@ -51,7 +63,7 @@ func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycom
 	if info.IsStream {
 		var responseText string
 		err, responseText = geminiChatStreamHandler(c, resp)
-		usage = service.ResponseText2Usage(responseText, info.UpstreamModelName, info.PromptTokens)
+		usage, _ = service.ResponseText2Usage(responseText, info.UpstreamModelName, info.PromptTokens)
 	} else {
 		err, usage = geminiChatHandler(c, resp, info.PromptTokens, info.UpstreamModelName)
 	}
--- a/relay/channel/gemini/constant.go
+++ b/relay/channel/gemini/constant.go
@@ -5,8 +5,8 @@ const (
 )

 var ModelList = []string{
-	"gemini-pro",
-	"gemini-pro-vision",
+	"gemini-1.0-pro-latest", "gemini-1.0-pro-001", "gemini-1.5-pro-latest", "gemini-ultra",
+	"gemini-1.0-pro-vision-latest", "gemini-1.0-pro-vision-001",
 }

 var ChannelName = "google gemini"
--- a/relay/channel/gemini/relay-gemini.go
+++ b/relay/channel/gemini/relay-gemini.go
@@ -256,7 +256,7 @@ func geminiChatHandler(c *gin.Context, resp *http.Response, promptTokens int, mo
 		}, nil
 	}
 	fullTextResponse := responseGeminiChat2OpenAI(&geminiResponse)
-	completionTokens := service.CountTokenText(geminiResponse.GetResponseText(), model)
+	completionTokens, _, _ := service.CountTokenText(geminiResponse.GetResponseText(), model, false)
 	usage := dto.Usage{
 		PromptTokens:     promptTokens,
 		CompletionTokens: completionTokens,
--- a/relay/channel/lingyiwanwu/constrants.go
+++ b/relay/channel/lingyiwanwu/constrants.go
@@ -0,0 +1,9 @@
+package lingyiwanwu
+
+// https://platform.lingyiwanwu.com/docs
+
+var ModelList = []string{
+	"yi-34b-chat-0205",
+	"yi-34b-chat-200k",
+	"yi-vl-plus",
+}
--- a/relay/channel/ollama/adaptor.go
+++ b/relay/channel/ollama/adaptor.go
@@ -0,0 +1,73 @@
+package ollama
+
+import (
+	"errors"
+	"github.com/gin-gonic/gin"
+	"io"
+	"net/http"
+	"one-api/dto"
+	"one-api/relay/channel"
+	"one-api/relay/channel/openai"
+	relaycommon "one-api/relay/common"
+	relayconstant "one-api/relay/constant"
+	"one-api/service"
+)
+
+type Adaptor struct {
+}
+
+func (a *Adaptor) Init(info *relaycommon.RelayInfo, request dto.GeneralOpenAIRequest) {
+}
+
+func (a *Adaptor) GetRequestURL(info *relaycommon.RelayInfo) (string, error) {
+	switch info.RelayMode {
+	case relayconstant.RelayModeEmbeddings:
+		return info.BaseUrl + "/api/embeddings", nil
+	default:
+		return relaycommon.GetFullRequestURL(info.BaseUrl, info.RequestURLPath, info.ChannelType), nil
+	}
+}
+
+func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Request, info *relaycommon.RelayInfo) error {
+	channel.SetupApiRequestHeader(info, c, req)
+	return nil
+}
+
+func (a *Adaptor) ConvertRequest(c *gin.Context, relayMode int, request *dto.GeneralOpenAIRequest) (any, error) {
+	if request == nil {
+		return nil, errors.New("request is nil")
+	}
+	switch relayMode {
+	case relayconstant.RelayModeEmbeddings:
+		return requestOpenAI2Embeddings(*request), nil
+	default:
+		return requestOpenAI2Ollama(*request), nil
+	}
+}
+
+func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, requestBody io.Reader) (*http.Response, error) {
+	return channel.DoApiRequest(a, c, info, requestBody)
+}
+
+func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo) (usage *dto.Usage, err *dto.OpenAIErrorWithStatusCode) {
+	if info.IsStream {
+		var responseText string
+		err, responseText = openai.OpenaiStreamHandler(c, resp, info.RelayMode)
+		usage, _ = service.ResponseText2Usage(responseText, info.UpstreamModelName, info.PromptTokens)
+	} else {
+		if info.RelayMode == relayconstant.RelayModeEmbeddings {
+			err, usage = ollamaEmbeddingHandler(c, resp, info.PromptTokens, info.UpstreamModelName, info.RelayMode)
+		} else {
+			err, usage = openai.OpenaiHandler(c, resp, info.PromptTokens, info.UpstreamModelName)
+		}
+	}
+	return
+}
+
+func (a *Adaptor) GetModelList() []string {
+	return ModelList
+}
+
+func (a *Adaptor) GetChannelName() string {
+	return ChannelName
+}
--- a/relay/channel/ollama/constants.go
+++ b/relay/channel/ollama/constants.go
@@ -0,0 +1,5 @@
+package ollama
+
+var ModelList []string
+
+var ChannelName = "ollama"
--- a/relay/channel/ollama/dto.go
+++ b/relay/channel/ollama/dto.go
@@ -0,0 +1,26 @@
+package ollama
+
+import "one-api/dto"
+
+type OllamaRequest struct {
+	Model       string        `json:"model,omitempty"`
+	Messages    []dto.Message `json:"messages,omitempty"`
+	Stream      bool          `json:"stream,omitempty"`
+	Temperature float64       `json:"temperature,omitempty"`
+	Seed        float64       `json:"seed,omitempty"`
+	Topp        float64       `json:"top_p,omitempty"`
+	TopK        int           `json:"top_k,omitempty"`
+	Stop        any           `json:"stop,omitempty"`
+}
+
+type OllamaEmbeddingRequest struct {
+	Model  string `json:"model,omitempty"`
+	Prompt any    `json:"prompt,omitempty"`
+}
+
+type OllamaEmbeddingResponse struct {
+	Embedding []float64 `json:"embedding,omitempty"`
+}
+
+//type OllamaOptions struct {
+//}
--- a/relay/channel/ollama/relay-ollama.go
+++ b/relay/channel/ollama/relay-ollama.go
@@ -0,0 +1,109 @@
+package ollama
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"io"
+	"net/http"
+	"one-api/dto"
+	"one-api/service"
+	"strings"
+)
+
+func requestOpenAI2Ollama(request dto.GeneralOpenAIRequest) *OllamaRequest {
+	messages := make([]dto.Message, 0, len(request.Messages))
+	for _, message := range request.Messages {
+		messages = append(messages, dto.Message{
+			Role:    message.Role,
+			Content: message.Content,
+		})
+	}
+	str, ok := request.Stop.(string)
+	var Stop []string
+	if ok {
+		Stop = []string{str}
+	} else {
+		Stop, _ = request.Stop.([]string)
+	}
+	return &OllamaRequest{
+		Model:       request.Model,
+		Messages:    messages,
+		Stream:      request.Stream,
+		Temperature: request.Temperature,
+		Seed:        request.Seed,
+		Topp:        request.TopP,
+		TopK:        request.TopK,
+		Stop:        Stop,
+	}
+}
+
+func requestOpenAI2Embeddings(request dto.GeneralOpenAIRequest) *OllamaEmbeddingRequest {
+	return &OllamaEmbeddingRequest{
+		Model:  request.Model,
+		Prompt: strings.Join(request.ParseInput(), " "),
+	}
+}
+
+func ollamaEmbeddingHandler(c *gin.Context, resp *http.Response, promptTokens int, model string, relayMode int) (*dto.OpenAIErrorWithStatusCode, *dto.Usage) {
+	var ollamaEmbeddingResponse OllamaEmbeddingResponse
+	responseBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return service.OpenAIErrorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
+	}
+	err = resp.Body.Close()
+	if err != nil {
+		return service.OpenAIErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
+	}
+	err = json.Unmarshal(responseBody, &ollamaEmbeddingResponse)
+	if err != nil {
+		return service.OpenAIErrorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
+	}
+	data := make([]dto.OpenAIEmbeddingResponseItem, 0, 1)
+	data = append(data, dto.OpenAIEmbeddingResponseItem{
+		Embedding: ollamaEmbeddingResponse.Embedding,
+		Object:    "embedding",
+	})
+	usage := &dto.Usage{
+		TotalTokens:      promptTokens,
+		CompletionTokens: 0,
+		PromptTokens:     promptTokens,
+	}
+	embeddingResponse := &dto.OpenAIEmbeddingResponse{
+		Object: "list",
+		Data:   data,
+		Model:  model,
+		Usage:  *usage,
+	}
+	doResponseBody, err := json.Marshal(embeddingResponse)
+	if err != nil {
+		return service.OpenAIErrorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
+	}
+	resp.Body = io.NopCloser(bytes.NewBuffer(doResponseBody))
+	// We shouldn't set the header before we parse the response body, because the parse part may fail.
+	// And then we will have to send an error response, but in this case, the header has already been set.
+	// So the httpClient will be confused by the response.
+	// For example, Postman will report error, and we cannot check the response at all.
+	// Copy headers
+	for k, v := range resp.Header {
+		// 删除任何现有的相同头部，以防止重复添加头部
+		c.Writer.Header().Del(k)
+		for _, vv := range v {
+			c.Writer.Header().Add(k, vv)
+		}
+	}
+	// reset content length
+	c.Writer.Header().Del("Content-Length")
+	c.Writer.Header().Set("Content-Length", fmt.Sprintf("%d", len(doResponseBody)))
+	c.Writer.WriteHeader(resp.StatusCode)
+	_, err = io.Copy(c.Writer, resp.Body)
+	if err != nil {
+		return service.OpenAIErrorWrapper(err, "copy_response_body_failed", http.StatusInternalServerError), nil
+	}
+	err = resp.Body.Close()
+	if err != nil {
+		return service.OpenAIErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
+	}
+	return nil, usage
+}
--- a/relay/channel/openai/adaptor.go
+++ b/relay/channel/openai/adaptor.go
@@ -10,6 +10,7 @@ import (
 	"one-api/dto"
 	"one-api/relay/channel"
 	"one-api/relay/channel/ai360"
+	"one-api/relay/channel/lingyiwanwu"
 	"one-api/relay/channel/moonshot"
 	relaycommon "one-api/relay/common"
 	"one-api/service"
@@ -33,9 +34,6 @@ func (a *Adaptor) GetRequestURL(info *relaycommon.RelayInfo) (string, error) {
 		model_ := info.UpstreamModelName
 		model_ = strings.Replace(model_, ".", "", -1)
 		// https://github.com/songquanpeng/one-api/issues/67
-		model_ = strings.TrimSuffix(model_, "-0301")
-		model_ = strings.TrimSuffix(model_, "-0314")
-		model_ = strings.TrimSuffix(model_, "-0613")

 		requestURL = fmt.Sprintf("/openai/deployments/%s/%s", model_, task)
 		return relaycommon.GetFullRequestURL(info.BaseUrl, requestURL, info.ChannelType), nil
@@ -49,6 +47,9 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Request, info *re
 		req.Header.Set("api-key", info.ApiKey)
 		return nil
 	}
+	if info.ChannelType == common.ChannelTypeOpenAI && "" != info.Organization {
+		req.Header.Set("OpenAI-Organization", info.Organization)
+	}
 	req.Header.Set("Authorization", "Bearer "+info.ApiKey)
 	//if info.ChannelType == common.ChannelTypeOpenRouter {
 	//	req.Header.Set("HTTP-Referer", "https://github.com/songquanpeng/one-api")
@@ -72,7 +73,7 @@ func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycom
 	if info.IsStream {
 		var responseText string
 		err, responseText = OpenaiStreamHandler(c, resp, info.RelayMode)
-		usage = service.ResponseText2Usage(responseText, info.UpstreamModelName, info.PromptTokens)
+		usage, _ = service.ResponseText2Usage(responseText, info.UpstreamModelName, info.PromptTokens)
 	} else {
 		err, usage = OpenaiHandler(c, resp, info.PromptTokens, info.UpstreamModelName)
 	}
@@ -85,6 +86,8 @@ func (a *Adaptor) GetModelList() []string {
 		return ai360.ModelList
 	case common.ChannelTypeMoonshot:
 		return moonshot.ModelList
+	case common.ChannelTypeLingYiWanWu:
+		return lingyiwanwu.ModelList
 	default:
 		return ModelList
 	}
--- a/relay/channel/openai/relay-openai.go
+++ b/relay/channel/openai/relay-openai.go
@@ -17,6 +17,7 @@ import (
 )

 func OpenaiStreamHandler(c *gin.Context, resp *http.Response, relayMode int) (*dto.OpenAIErrorWithStatusCode, string) {
+	//checkSensitive := constant.ShouldCheckCompletionSensitive()
 	var responseTextBuilder strings.Builder
 	scanner := bufio.NewScanner(resp.Body)
 	scanner.Split(func(data []byte, atEOF bool) (advance int, token []byte, err error) {
@@ -36,11 +37,10 @@ func OpenaiStreamHandler(c *gin.Context, resp *http.Response, relayMode int) (*d
 	defer close(stopChan)
 	defer close(dataChan)
 	var wg sync.WaitGroup
-
 	go func() {
 		wg.Add(1)
 		defer wg.Done()
-		var streamItems []string
+		var streamItems []string // store stream items
 		for scanner.Scan() {
 			data := scanner.Text()
 			if len(data) < 6 { // ignore blank line or wrong format
@@ -62,11 +62,32 @@ func OpenaiStreamHandler(c *gin.Context, resp *http.Response, relayMode int) (*d
 			err := json.Unmarshal(common.StringToByteSlice(streamResp), &streamResponses)
 			if err != nil {
 				common.SysError("error unmarshalling stream response: " + err.Error())
-				return // just ignore the error
-			}
-			for _, streamResponse := range streamResponses {
-				for _, choice := range streamResponse.Choices {
-					responseTextBuilder.WriteString(choice.Delta.Content)
+				for _, item := range streamItems {
+					var streamResponse dto.ChatCompletionsStreamResponseSimple
+					err := json.Unmarshal(common.StringToByteSlice(item), &streamResponse)
+					if err == nil {
+						for _, choice := range streamResponse.Choices {
+							responseTextBuilder.WriteString(choice.Delta.Content)
+							if choice.Delta.ToolCalls != nil {
+								for _, tool := range choice.Delta.ToolCalls {
+									responseTextBuilder.WriteString(tool.Function.Name)
+									responseTextBuilder.WriteString(tool.Function.Arguments)
+								}
+							}
+						}
+					}
+				}
+			} else {
+				for _, streamResponse := range streamResponses {
+					for _, choice := range streamResponse.Choices {
+						responseTextBuilder.WriteString(choice.Delta.Content)
+						if choice.Delta.ToolCalls != nil {
+							for _, tool := range choice.Delta.ToolCalls {
+								responseTextBuilder.WriteString(tool.Function.Name)
+								responseTextBuilder.WriteString(tool.Function.Arguments)
+							}
+						}
+					}
 				}
 			}
 		case relayconstant.RelayModeCompletions:
@@ -74,11 +95,20 @@ func OpenaiStreamHandler(c *gin.Context, resp *http.Response, relayMode int) (*d
 			err := json.Unmarshal(common.StringToByteSlice(streamResp), &streamResponses)
 			if err != nil {
 				common.SysError("error unmarshalling stream response: " + err.Error())
-				return // just ignore the error
-			}
-			for _, streamResponse := range streamResponses {
-				for _, choice := range streamResponse.Choices {
-					responseTextBuilder.WriteString(choice.Text)
+				for _, item := range streamItems {
+					var streamResponse dto.CompletionsStreamResponse
+					err := json.Unmarshal(common.StringToByteSlice(item), &streamResponse)
+					if err == nil {
+						for _, choice := range streamResponse.Choices {
+							responseTextBuilder.WriteString(choice.Text)
+						}
+					}
+				}
+			} else {
+				for _, streamResponse := range streamResponses {
+					for _, choice := range streamResponse.Choices {
+						responseTextBuilder.WriteString(choice.Text)
+					}
 				}
 			}
 		}
@@ -112,7 +142,7 @@ func OpenaiStreamHandler(c *gin.Context, resp *http.Response, relayMode int) (*d
 }

 func OpenaiHandler(c *gin.Context, resp *http.Response, promptTokens int, model string) (*dto.OpenAIErrorWithStatusCode, *dto.Usage) {
-	var textResponse dto.TextResponse
+	var simpleResponse dto.SimpleResponse
 	responseBody, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return service.OpenAIErrorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
@@ -121,13 +151,13 @@ func OpenaiHandler(c *gin.Context, resp *http.Response, promptTokens int, model
 	if err != nil {
 		return service.OpenAIErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
 	}
-	err = json.Unmarshal(responseBody, &textResponse)
+	err = json.Unmarshal(responseBody, &simpleResponse)
 	if err != nil {
 		return service.OpenAIErrorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
 	}
-	if textResponse.Error.Type != "" {
+	if simpleResponse.Error.Type != "" {
 		return &dto.OpenAIErrorWithStatusCode{
-			Error:      textResponse.Error,
+			Error:      simpleResponse.Error,
 			StatusCode: resp.StatusCode,
 		}, nil
 	}
@@ -150,16 +180,17 @@ func OpenaiHandler(c *gin.Context, resp *http.Response, promptTokens int, model
 		return service.OpenAIErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
 	}

-	if textResponse.Usage.TotalTokens == 0 {
+	if simpleResponse.Usage.TotalTokens == 0 {
 		completionTokens := 0
-		for _, choice := range textResponse.Choices {
-			completionTokens += service.CountTokenText(string(choice.Message.Content), model)
+		for _, choice := range simpleResponse.Choices {
+			ctkm, _, _ := service.CountTokenText(string(choice.Message.Content), model, false)
+			completionTokens += ctkm
 		}
-		textResponse.Usage = dto.Usage{
+		simpleResponse.Usage = dto.Usage{
 			PromptTokens:     promptTokens,
 			CompletionTokens: completionTokens,
 			TotalTokens:      promptTokens + completionTokens,
 		}
 	}
-	return nil, &textResponse.Usage
+	return nil, &simpleResponse.Usage
 }
--- a/relay/channel/palm/adaptor.go
+++ b/relay/channel/palm/adaptor.go
@@ -43,7 +43,7 @@ func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycom
 	if info.IsStream {
 		var responseText string
 		err, responseText = palmStreamHandler(c, resp)
-		usage = service.ResponseText2Usage(responseText, info.UpstreamModelName, info.PromptTokens)
+		usage, _ = service.ResponseText2Usage(responseText, info.UpstreamModelName, info.PromptTokens)
 	} else {
 		err, usage = palmHandler(c, resp, info.PromptTokens, info.UpstreamModelName)
 	}
--- a/relay/channel/palm/relay-palm.go
+++ b/relay/channel/palm/relay-palm.go
@@ -156,7 +156,7 @@ func palmHandler(c *gin.Context, resp *http.Response, promptTokens int, model st
 		}, nil
 	}
 	fullTextResponse := responsePaLM2OpenAI(&palmResponse)
-	completionTokens := service.CountTokenText(palmResponse.Candidates[0].Content, model)
+	completionTokens, _, _ := service.CountTokenText(palmResponse.Candidates[0].Content, model, false)
 	usage := dto.Usage{
 		PromptTokens:     promptTokens,
 		CompletionTokens: completionTokens,
--- a/relay/channel/perplexity/adaptor.go
+++ b/relay/channel/perplexity/adaptor.go
@@ -0,0 +1,63 @@
+package perplexity
+
+import (
+	"errors"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"io"
+	"net/http"
+	"one-api/dto"
+	"one-api/relay/channel"
+	"one-api/relay/channel/openai"
+	relaycommon "one-api/relay/common"
+	"one-api/service"
+)
+
+type Adaptor struct {
+}
+
+func (a *Adaptor) Init(info *relaycommon.RelayInfo, request dto.GeneralOpenAIRequest) {
+}
+
+func (a *Adaptor) GetRequestURL(info *relaycommon.RelayInfo) (string, error) {
+	return fmt.Sprintf("%s/chat/completions", info.BaseUrl), nil
+}
+
+func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Request, info *relaycommon.RelayInfo) error {
+	channel.SetupApiRequestHeader(info, c, req)
+	req.Header.Set("Authorization", "Bearer "+info.ApiKey)
+	return nil
+}
+
+func (a *Adaptor) ConvertRequest(c *gin.Context, relayMode int, request *dto.GeneralOpenAIRequest) (any, error) {
+	if request == nil {
+		return nil, errors.New("request is nil")
+	}
+	if request.TopP >= 1 {
+		request.TopP = 0.99
+	}
+	return requestOpenAI2Perplexity(*request), nil
+}
+
+func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, requestBody io.Reader) (*http.Response, error) {
+	return channel.DoApiRequest(a, c, info, requestBody)
+}
+
+func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo) (usage *dto.Usage, err *dto.OpenAIErrorWithStatusCode) {
+	if info.IsStream {
+		var responseText string
+		err, responseText = openai.OpenaiStreamHandler(c, resp, info.RelayMode)
+		usage, _ = service.ResponseText2Usage(responseText, info.UpstreamModelName, info.PromptTokens)
+	} else {
+		err, usage = openai.OpenaiHandler(c, resp, info.PromptTokens, info.UpstreamModelName)
+	}
+	return
+}
+
+func (a *Adaptor) GetModelList() []string {
+	return ModelList
+}
+
+func (a *Adaptor) GetChannelName() string {
+	return ChannelName
+}
--- a/relay/channel/perplexity/constants.go
+++ b/relay/channel/perplexity/constants.go
@@ -0,0 +1,7 @@
+package perplexity
+
+var ModelList = []string{
+	"sonar-small-chat", "sonar-small-online", "sonar-medium-chat", "sonar-medium-online", "mistral-7b-instruct", "mixtral-8x7b-instruct",
+}
+
+var ChannelName = "perplexity"
--- a/relay/channel/perplexity/relay-perplexity.go
+++ b/relay/channel/perplexity/relay-perplexity.go
@@ -0,0 +1,21 @@
+package perplexity
+
+import "one-api/dto"
+
+func requestOpenAI2Perplexity(request dto.GeneralOpenAIRequest) *dto.GeneralOpenAIRequest {
+	messages := make([]dto.Message, 0, len(request.Messages))
+	for _, message := range request.Messages {
+		messages = append(messages, dto.Message{
+			Role:    message.Role,
+			Content: message.Content,
+		})
+	}
+	return &dto.GeneralOpenAIRequest{
+		Model:       request.Model,
+		Stream:      request.Stream,
+		Messages:    messages,
+		Temperature: request.Temperature,
+		TopP:        request.TopP,
+		MaxTokens:   request.MaxTokens,
+	}
+}
--- a/relay/channel/tencent/adaptor.go
+++ b/relay/channel/tencent/adaptor.go
@@ -57,7 +57,7 @@ func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycom
 	if info.IsStream {
 		var responseText string
 		err, responseText = tencentStreamHandler(c, resp)
-		usage = service.ResponseText2Usage(responseText, info.UpstreamModelName, info.PromptTokens)
+		usage, _ = service.ResponseText2Usage(responseText, info.UpstreamModelName, info.PromptTokens)
 	} else {
 		err, usage = tencentHandler(c, resp)
 	}
--- a/relay/channel/xunfei/relay-xunfei.go
+++ b/relay/channel/xunfei/relay-xunfei.go
@@ -179,7 +179,13 @@ func xunfeiHandler(c *gin.Context, textRequest dto.GeneralOpenAIRequest, appId s
 		case stop = <-stopChan:
 		}
 	}
-
+	if len(xunfeiResponse.Payload.Choices.Text) == 0 {
+		xunfeiResponse.Payload.Choices.Text = []XunfeiChatResponseTextItem{
+			{
+				Content: "",
+			},
+		}
+	}
 	xunfeiResponse.Payload.Choices.Text[0].Content = content

 	response := responseXunfei2OpenAI(&xunfeiResponse)
--- a/relay/channel/zhipu/adaptor.go
+++ b/relay/channel/zhipu/adaptor.go
@@ -36,6 +36,9 @@ func (a *Adaptor) ConvertRequest(c *gin.Context, relayMode int, request *dto.Gen
 	if request == nil {
 		return nil, errors.New("request is nil")
 	}
+	if request.TopP >= 1 {
+		request.TopP = 0.99
+	}
 	return requestOpenAI2Zhipu(*request), nil
 }

--- a/relay/channel/zhipu_4v/adaptor.go
+++ b/relay/channel/zhipu_4v/adaptor.go
@@ -34,6 +34,9 @@ func (a *Adaptor) ConvertRequest(c *gin.Context, relayMode int, request *dto.Gen
 	if request == nil {
 		return nil, errors.New("request is nil")
 	}
+	if request.TopP >= 1 {
+		request.TopP = 0.99
+	}
 	return requestOpenAI2Zhipu(*request), nil
 }

@@ -45,7 +48,7 @@ func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycom
 	if info.IsStream {
 		var responseText string
 		err, responseText = openai.OpenaiStreamHandler(c, resp, info.RelayMode)
-		usage = service.ResponseText2Usage(responseText, info.UpstreamModelName, info.PromptTokens)
+		usage, _ = service.ResponseText2Usage(responseText, info.UpstreamModelName, info.PromptTokens)
 	} else {
 		err, usage = openai.OpenaiHandler(c, resp, info.PromptTokens, info.UpstreamModelName)
 	}
--- a/relay/channel/zhipu_4v/relay-zhipu_v4.go
+++ b/relay/channel/zhipu_4v/relay-zhipu_v4.go
@@ -74,6 +74,25 @@ func getZhipuToken(apikey string) string {
 func requestOpenAI2Zhipu(request dto.GeneralOpenAIRequest) *dto.GeneralOpenAIRequest {
 	messages := make([]dto.Message, 0, len(request.Messages))
 	for _, message := range request.Messages {
+		if !message.IsStringContent() {
+			mediaMessages := message.ParseContent()
+			for j, mediaMessage := range mediaMessages {
+				if mediaMessage.Type == dto.ContentTypeImageURL {
+					imageUrl := mediaMessage.ImageUrl.(dto.MessageImageUrl)
+					// check if base64
+					if strings.HasPrefix(imageUrl.Url, "data:image/") {
+						// 去除base64数据的URL前缀（如果有）
+						if idx := strings.Index(imageUrl.Url, ","); idx != -1 {
+							imageUrl.Url = imageUrl.Url[idx+1:]
+						}
+					}
+					mediaMessage.ImageUrl = imageUrl
+					mediaMessages[j] = mediaMessage
+				}
+			}
+			messageRaw, _ := json.Marshal(mediaMessages)
+			message.Content = messageRaw
+		}
 		messages = append(messages, dto.Message{
 			Role:       message.Role,
 			Content:    message.Content,
@@ -138,7 +157,7 @@ func streamResponseZhipu2OpenAI(zhipuResponse *ZhipuV4StreamResponse) *dto.ChatC
 		Id:      zhipuResponse.Id,
 		Object:  "chat.completion.chunk",
 		Created: zhipuResponse.Created,
-		Model:   "glm-4",
+		Model:   "glm-4v",
 		Choices: []dto.ChatCompletionsStreamResponseChoice{choice},
 	}
 	return &response
--- a/relay/common/relay_info.go
+++ b/relay/common/relay_info.go
@@ -24,12 +24,14 @@ type RelayInfo struct {
 	ApiVersion        string
 	PromptTokens      int
 	ApiKey            string
+	Organization      string
 	BaseUrl           string
 }

 func GenRelayInfo(c *gin.Context) *RelayInfo {
 	channelType := c.GetInt("channel")
 	channelId := c.GetInt("channel_id")
+
 	tokenId := c.GetInt("token_id")
 	userId := c.GetInt("id")
 	group := c.GetString("group")
@@ -52,6 +54,7 @@ func GenRelayInfo(c *gin.Context) *RelayInfo {
 		ApiType:        apiType,
 		ApiVersion:     c.GetString("api_version"),
 		ApiKey:         strings.TrimPrefix(c.Request.Header.Get("Authorization"), "Bearer "),
+		Organization:   c.GetString("channel_organization"),
 	}
 	if info.BaseUrl == "" {
 		info.BaseUrl = common.ChannelBaseURLs[channelType]
--- a/relay/common/relay_utils.go
+++ b/relay/common/relay_utils.go
@@ -35,7 +35,7 @@ func RelayErrorHandler(resp *http.Response) (OpenAIErrorWithStatusCode *dto.Open
 	if err != nil {
 		return
 	}
-	var textResponse dto.TextResponse
+	var textResponse dto.TextResponseWithError
 	err = json.Unmarshal(responseBody, &textResponse)
 	if err != nil {
 		return
--- a/relay/constant/api_type.go
+++ b/relay/constant/api_type.go
@@ -16,6 +16,9 @@ const (
 	APITypeTencent
 	APITypeGemini
 	APITypeZhipu_v4
+	APITypeOllama
+	APITypePerplexity
+	APITypeAws

 	APITypeDummy // this one is only for count, do not add any channel after this
 )
@@ -43,6 +46,12 @@ func ChannelType2APIType(channelType int) int {
 		apiType = APITypeGemini
 	case common.ChannelTypeZhipu_v4:
 		apiType = APITypeZhipu_v4
+	case common.ChannelTypeOllama:
+		apiType = APITypeOllama
+	case common.ChannelTypePerplexity:
+		apiType = APITypePerplexity
+	case common.ChannelTypeAws:
+		apiType = APITypeAws
 	}
 	return apiType
 }
--- a/relay/constant/relay_mode.go
+++ b/relay/constant/relay_mode.go
@@ -17,10 +17,15 @@ const (
 	RelayModeMidjourneySimpleChange
 	RelayModeMidjourneyNotify
 	RelayModeMidjourneyTaskFetch
+	RelayModeMidjourneyTaskImageSeed
 	RelayModeMidjourneyTaskFetchByCondition
 	RelayModeAudioSpeech
 	RelayModeAudioTranscription
 	RelayModeAudioTranslation
+	RelayModeMidjourneyAction
+	RelayModeMidjourneyModal
+	RelayModeMidjourneyShorten
+	RelayModeSwapFace
 )

 func Path2RelayMode(path string) int {
@@ -48,3 +53,39 @@ func Path2RelayMode(path string) int {
 	}
 	return relayMode
 }
+
+func Path2RelayModeMidjourney(path string) int {
+	relayMode := RelayModeUnknown
+	if strings.HasSuffix(path, "/mj/submit/action") {
+		// midjourney plus
+		relayMode = RelayModeMidjourneyAction
+	} else if strings.HasSuffix(path, "/mj/submit/modal") {
+		// midjourney plus
+		relayMode = RelayModeMidjourneyModal
+	} else if strings.HasSuffix(path, "/mj/submit/shorten") {
+		// midjourney plus
+		relayMode = RelayModeMidjourneyShorten
+	} else if strings.HasSuffix(path, "/mj/insight-face/swap") {
+		// midjourney plus
+		relayMode = RelayModeSwapFace
+	} else if strings.HasSuffix(path, "/mj/submit/imagine") {
+		relayMode = RelayModeMidjourneyImagine
+	} else if strings.HasSuffix(path, "/mj/submit/blend") {
+		relayMode = RelayModeMidjourneyBlend
+	} else if strings.HasSuffix(path, "/mj/submit/describe") {
+		relayMode = RelayModeMidjourneyDescribe
+	} else if strings.HasSuffix(path, "/mj/notify") {
+		relayMode = RelayModeMidjourneyNotify
+	} else if strings.HasSuffix(path, "/mj/submit/change") {
+		relayMode = RelayModeMidjourneyChange
+	} else if strings.HasSuffix(path, "/mj/submit/simple-change") {
+		relayMode = RelayModeMidjourneyChange
+	} else if strings.HasSuffix(path, "/fetch") {
+		relayMode = RelayModeMidjourneyTaskFetch
+	} else if strings.HasSuffix(path, "/image-seed") {
+		relayMode = RelayModeMidjourneyTaskImageSeed
+	} else if strings.HasSuffix(path, "/list-by-condition") {
+		relayMode = RelayModeMidjourneyTaskFetchByCondition
+	}
+	return relayMode
+}
--- a/relay/relay-audio.go
+++ b/relay/relay-audio.go
@@ -10,6 +10,7 @@ import (
 	"io"
 	"net/http"
 	"one-api/common"
+	"one-api/constant"
 	"one-api/dto"
 	"one-api/model"
 	relaycommon "one-api/relay/common"
@@ -62,8 +63,16 @@ func AudioHelper(c *gin.Context, relayMode int) *dto.OpenAIErrorWithStatusCode {
 			return service.OpenAIErrorWrapper(errors.New("voice must be one of "+strings.Join(availableVoices, ", ")), "invalid_field_value", http.StatusBadRequest)
 		}
 	}
-
+	var err error
+	promptTokens := 0
 	preConsumedTokens := common.PreConsumedQuota
+	if strings.HasPrefix(audioRequest.Model, "tts-1") {
+		promptTokens, err, _ = service.CountAudioToken(audioRequest.Input, audioRequest.Model, constant.ShouldCheckPromptSensitive())
+		if err != nil {
+			return service.OpenAIErrorWrapper(err, "count_audio_token_failed", http.StatusInternalServerError)
+		}
+		preConsumedTokens = promptTokens
+	}
 	modelRatio := common.GetModelRatio(audioRequest.Model)
 	groupRatio := common.GetGroupRatio(group)
 	ratio := modelRatio * groupRatio
@@ -161,12 +170,10 @@ func AudioHelper(c *gin.Context, relayMode int) *dto.OpenAIErrorWithStatusCode {
 		go func() {
 			useTimeSeconds := time.Now().Unix() - startTime.Unix()
 			quota := 0
-			var promptTokens = 0
 			if strings.HasPrefix(audioRequest.Model, "tts-1") {
-				quota = service.CountAudioToken(audioRequest.Input, audioRequest.Model)
-				promptTokens = quota
+				quota = promptTokens
 			} else {
-				quota = service.CountAudioToken(audioResponse.Text, audioRequest.Model)
+				quota, err, _ = service.CountAudioToken(audioResponse.Text, audioRequest.Model, false)
 			}
 			quota = int(float64(quota) * ratio)
 			if ratio != 0 && quota <= 0 {
@@ -208,6 +215,10 @@ func AudioHelper(c *gin.Context, relayMode int) *dto.OpenAIErrorWithStatusCode {
 		if err != nil {
 			return service.OpenAIErrorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError)
 		}
+		contains, words := service.SensitiveWordContains(audioResponse.Text)
+		if contains {
+			return service.OpenAIErrorWrapper(errors.New("response contains sensitive words: "+strings.Join(words, ", ")), "response_contains_sensitive_words", http.StatusBadRequest)
+		}
 	}

 	resp.Body = io.NopCloser(bytes.NewBuffer(responseBody))
--- a/relay/relay-image.go
+++ b/relay/relay-image.go
@@ -24,16 +24,13 @@ func RelayImageHelper(c *gin.Context, relayMode int) *dto.OpenAIErrorWithStatusC
 	channelType := c.GetInt("channel")
 	channelId := c.GetInt("channel_id")
 	userId := c.GetInt("id")
-	consumeQuota := c.GetBool("consume_quota")
 	group := c.GetString("group")
 	startTime := time.Now()

 	var imageRequest dto.ImageRequest
-	if consumeQuota {
-		err := common.UnmarshalBodyReusable(c, &imageRequest)
-		if err != nil {
-			return service.OpenAIErrorWrapper(err, "bind_request_body_failed", http.StatusBadRequest)
-		}
+	err := common.UnmarshalBodyReusable(c, &imageRequest)
+	if err != nil {
+		return service.OpenAIErrorWrapper(err, "bind_request_body_failed", http.StatusBadRequest)
 	}

 	if imageRequest.Model == "" {
@@ -136,7 +133,7 @@ func RelayImageHelper(c *gin.Context, relayMode int) *dto.OpenAIErrorWithStatusC

 	quota := int(ratio*sizeRatio*qualityRatio*1000) * imageRequest.N

-	if consumeQuota && userQuota-quota < 0 {
+	if userQuota-quota < 0 {
 		return service.OpenAIErrorWrapper(errors.New("user quota is not enough"), "insufficient_user_quota", http.StatusForbidden)
 	}

@@ -176,46 +173,42 @@ func RelayImageHelper(c *gin.Context, relayMode int) *dto.OpenAIErrorWithStatusC
 	var textResponse dto.ImageResponse
 	defer func(ctx context.Context) {
 		useTimeSeconds := time.Now().Unix() - startTime.Unix()
-		if consumeQuota {
-			if resp.StatusCode != http.StatusOK {
-				return
-			}
-			err := model.PostConsumeTokenQuota(tokenId, userQuota, quota, 0, true)
-			if err != nil {
-				common.SysError("error consuming token remain quota: " + err.Error())
-			}
-			err = model.CacheUpdateUserQuota(userId)
-			if err != nil {
-				common.SysError("error update user quota cache: " + err.Error())
-			}
-			if quota != 0 {
-				tokenName := c.GetString("token_name")
-				logContent := fmt.Sprintf("模型倍率 %.2f，分组倍率 %.2f", modelRatio, groupRatio)
-				model.RecordConsumeLog(ctx, userId, channelId, 0, 0, imageRequest.Model, tokenName, quota, logContent, tokenId, userQuota, int(useTimeSeconds), false)
-				model.UpdateUserUsedQuotaAndRequestCount(userId, quota)
-				channelId := c.GetInt("channel_id")
-				model.UpdateChannelUsedQuota(channelId, quota)
-			}
+		if resp.StatusCode != http.StatusOK {
+			return
+		}
+		err := model.PostConsumeTokenQuota(tokenId, userQuota, quota, 0, true)
+		if err != nil {
+			common.SysError("error consuming token remain quota: " + err.Error())
+		}
+		err = model.CacheUpdateUserQuota(userId)
+		if err != nil {
+			common.SysError("error update user quota cache: " + err.Error())
+		}
+		if quota != 0 {
+			tokenName := c.GetString("token_name")
+			logContent := fmt.Sprintf("模型倍率 %.2f，分组倍率 %.2f", modelRatio, groupRatio)
+			model.RecordConsumeLog(ctx, userId, channelId, 0, 0, imageRequest.Model, tokenName, quota, logContent, tokenId, userQuota, int(useTimeSeconds), false)
+			model.UpdateUserUsedQuotaAndRequestCount(userId, quota)
+			channelId := c.GetInt("channel_id")
+			model.UpdateChannelUsedQuota(channelId, quota)
 		}
 	}(c.Request.Context())

-	if consumeQuota {
-		responseBody, err := io.ReadAll(resp.Body)
+	responseBody, err := io.ReadAll(resp.Body)

-		if err != nil {
-			return service.OpenAIErrorWrapper(err, "read_response_body_failed", http.StatusInternalServerError)
-		}
-		err = resp.Body.Close()
-		if err != nil {
-			return service.OpenAIErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError)
-		}
-		err = json.Unmarshal(responseBody, &textResponse)
-		if err != nil {
-			return service.OpenAIErrorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError)
-		}
-
-		resp.Body = io.NopCloser(bytes.NewBuffer(responseBody))
+	if err != nil {
+		return service.OpenAIErrorWrapper(err, "read_response_body_failed", http.StatusInternalServerError)
 	}
+	err = resp.Body.Close()
+	if err != nil {
+		return service.OpenAIErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError)
+	}
+	err = json.Unmarshal(responseBody, &textResponse)
+	if err != nil {
+		return service.OpenAIErrorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError)
+	}
+
+	resp.Body = io.NopCloser(bytes.NewBuffer(responseBody))

 	for k, v := range resp.Header {
 		c.Writer.Header().Set(k, v[0])
--- a/relay/relay-mj.go
+++ b/relay/relay-mj.go
@@ -9,6 +9,7 @@ import (
 	"log"
 	"net/http"
 	"one-api/common"
+	"one-api/constant"
 	"one-api/dto"
 	"one-api/model"
 	relayconstant "one-api/relay/constant"
@@ -20,53 +21,6 @@ import (
 	"github.com/gin-gonic/gin"
 )

-type Midjourney struct {
-	MjId        string `json:"id"`
-	Action      string `json:"action"`
-	Prompt      string `json:"prompt"`
-	PromptEn    string `json:"promptEn"`
-	Description string `json:"description"`
-	State       string `json:"state"`
-	SubmitTime  int64  `json:"submitTime"`
-	StartTime   int64  `json:"startTime"`
-	FinishTime  int64  `json:"finishTime"`
-	ImageUrl    string `json:"imageUrl"`
-	Status      string `json:"status"`
-	Progress    string `json:"progress"`
-	FailReason  string `json:"failReason"`
-}
-
-type MidjourneyStatus struct {
-	Status int `json:"status"`
-}
-type MidjourneyWithoutStatus struct {
-	Id          int    `json:"id"`
-	Code        int    `json:"code"`
-	UserId      int    `json:"user_id" gorm:"index"`
-	Action      string `json:"action"`
-	MjId        string `json:"mj_id" gorm:"index"`
-	Prompt      string `json:"prompt"`
-	PromptEn    string `json:"prompt_en"`
-	Description string `json:"description"`
-	State       string `json:"state"`
-	SubmitTime  int64  `json:"submit_time"`
-	StartTime   int64  `json:"start_time"`
-	FinishTime  int64  `json:"finish_time"`
-	ImageUrl    string `json:"image_url"`
-	Progress    string `json:"progress"`
-	FailReason  string `json:"fail_reason"`
-	ChannelId   int    `json:"channel_id"`
-}
-
-var DefaultModelPrice = map[string]float64{
-	"mj_imagine":   0.1,
-	"mj_variation": 0.1,
-	"mj_reroll":    0.1,
-	"mj_blend":     0.1,
-	"mj_describe":  0.05,
-	"mj_upscale":   0.05,
-}
-
 func RelayMidjourneyImage(c *gin.Context) {
 	taskId := c.Param("id")
 	midjourneyTask := model.GetByOnlyMJId(taskId)
@@ -108,7 +62,7 @@ func RelayMidjourneyImage(c *gin.Context) {
 }

 func RelayMidjourneyNotify(c *gin.Context) *dto.MidjourneyResponse {
-	var midjRequest Midjourney
+	var midjRequest dto.MidjourneyDto
 	err := common.UnmarshalBodyReusable(c, &midjRequest)
 	if err != nil {
 		return &dto.MidjourneyResponse{
@@ -147,7 +101,7 @@ func RelayMidjourneyNotify(c *gin.Context) *dto.MidjourneyResponse {
 	return nil
 }

-func getMidjourneyTaskModel(c *gin.Context, originTask *model.Midjourney) (midjourneyTask Midjourney) {
+func coverMidjourneyTaskDto(c *gin.Context, originTask *model.Midjourney) (midjourneyTask dto.MidjourneyDto) {
 	midjourneyTask.MjId = originTask.MjId
 	midjourneyTask.Progress = originTask.Progress
 	midjourneyTask.PromptEn = originTask.PromptEn
@@ -156,20 +110,177 @@ func getMidjourneyTaskModel(c *gin.Context, originTask *model.Midjourney) (midjo
 	midjourneyTask.StartTime = originTask.StartTime
 	midjourneyTask.FinishTime = originTask.FinishTime
 	midjourneyTask.ImageUrl = ""
-	if originTask.ImageUrl != "" {
+	if originTask.ImageUrl != "" && constant.MjForwardUrlEnabled {
 		midjourneyTask.ImageUrl = common.ServerAddress + "/mj/image/" + originTask.MjId
 		if originTask.Status != "SUCCESS" {
 			midjourneyTask.ImageUrl += "?rand=" + strconv.FormatInt(time.Now().UnixNano(), 10)
 		}
+	} else {
+		midjourneyTask.ImageUrl = originTask.ImageUrl
 	}
 	midjourneyTask.Status = originTask.Status
 	midjourneyTask.FailReason = originTask.FailReason
 	midjourneyTask.Action = originTask.Action
 	midjourneyTask.Description = originTask.Description
 	midjourneyTask.Prompt = originTask.Prompt
+	if originTask.Buttons != "" {
+		var buttons []dto.ActionButton
+		err := json.Unmarshal([]byte(originTask.Buttons), &buttons)
+		if err == nil {
+			midjourneyTask.Buttons = buttons
+		}
+	}
+	if originTask.Properties != "" {
+		var properties dto.Properties
+		err := json.Unmarshal([]byte(originTask.Properties), &properties)
+		if err == nil {
+			midjourneyTask.Properties = &properties
+		}
+	}
 	return
 }

+func RelaySwapFace(c *gin.Context) *dto.MidjourneyResponse {
+	startTime := time.Now().UnixNano() / int64(time.Millisecond)
+	tokenId := c.GetInt("token_id")
+	userId := c.GetInt("id")
+	group := c.GetString("group")
+	channelId := c.GetInt("channel_id")
+	var swapFaceRequest dto.SwapFaceRequest
+	err := common.UnmarshalBodyReusable(c, &swapFaceRequest)
+	if err != nil {
+		return service.MidjourneyErrorWrapper(constant.MjRequestError, "bind_request_body_failed")
+	}
+	if swapFaceRequest.SourceBase64 == "" || swapFaceRequest.TargetBase64 == "" {
+		return service.MidjourneyErrorWrapper(constant.MjRequestError, "sour_base64_and_target_base64_is_required")
+	}
+	modelName := service.CoverActionToModelName(constant.MjActionSwapFace)
+	modelPrice := common.GetModelPrice(modelName, true)
+	// 如果没有配置价格，则使用默认价格
+	if modelPrice == -1 {
+		defaultPrice, ok := common.DefaultModelPrice[modelName]
+		if !ok {
+			modelPrice = 0.1
+		} else {
+			modelPrice = defaultPrice
+		}
+	}
+	groupRatio := common.GetGroupRatio(group)
+	ratio := modelPrice * groupRatio
+	userQuota, err := model.CacheGetUserQuota(userId)
+	if err != nil {
+		return &dto.MidjourneyResponse{
+			Code:        4,
+			Description: err.Error(),
+		}
+	}
+	quota := int(ratio * common.QuotaPerUnit)
+
+	if userQuota-quota < 0 {
+		return &dto.MidjourneyResponse{
+			Code:        4,
+			Description: "quota_not_enough",
+		}
+	}
+	requestURL := getMjRequestPath(c.Request.URL.String())
+	baseURL := c.GetString("base_url")
+	fullRequestURL := fmt.Sprintf("%s%s", baseURL, requestURL)
+	mjResp, _, err := service.DoMidjourneyHttpRequest(c, time.Second*60, fullRequestURL)
+	if err != nil {
+		return &mjResp.Response
+	}
+	defer func(ctx context.Context) {
+		if mjResp.StatusCode == 200 && mjResp.Response.Code == 1 {
+			err := model.PostConsumeTokenQuota(tokenId, userQuota, quota, 0, true)
+			if err != nil {
+				common.SysError("error consuming token remain quota: " + err.Error())
+			}
+			err = model.CacheUpdateUserQuota(userId)
+			if err != nil {
+				common.SysError("error update user quota cache: " + err.Error())
+			}
+			if quota != 0 {
+				tokenName := c.GetString("token_name")
+				logContent := fmt.Sprintf("模型固定价格 %.2f，分组倍率 %.2f，操作 %s", modelPrice, groupRatio, constant.MjActionSwapFace)
+				model.RecordConsumeLog(ctx, userId, channelId, 0, 0, modelName, tokenName, quota, logContent, tokenId, userQuota, 0, false)
+				model.UpdateUserUsedQuotaAndRequestCount(userId, quota)
+				channelId := c.GetInt("channel_id")
+				model.UpdateChannelUsedQuota(channelId, quota)
+			}
+		}
+	}(c.Request.Context())
+	midjResponse := &mjResp.Response
+	midjourneyTask := &model.Midjourney{
+		UserId:      userId,
+		Code:        midjResponse.Code,
+		Action:      constant.MjActionSwapFace,
+		MjId:        midjResponse.Result,
+		Prompt:      "InsightFace",
+		PromptEn:    "",
+		Description: midjResponse.Description,
+		State:       "",
+		SubmitTime:  startTime,
+		StartTime:   time.Now().UnixNano() / int64(time.Millisecond),
+		FinishTime:  0,
+		ImageUrl:    "",
+		Status:      "",
+		Progress:    "0%",
+		FailReason:  "",
+		ChannelId:   c.GetInt("channel_id"),
+		Quota:       quota,
+	}
+	err = midjourneyTask.Insert()
+	if err != nil {
+		return service.MidjourneyErrorWrapper(constant.MjRequestError, "insert_midjourney_task_failed")
+	}
+	c.Writer.WriteHeader(mjResp.StatusCode)
+	respBody, err := json.Marshal(midjResponse)
+	if err != nil {
+		return service.MidjourneyErrorWrapper(constant.MjRequestError, "unmarshal_response_body_failed")
+	}
+	_, err = io.Copy(c.Writer, bytes.NewBuffer(respBody))
+	if err != nil {
+		return service.MidjourneyErrorWrapper(constant.MjRequestError, "copy_response_body_failed")
+	}
+	return nil
+}
+
+func RelayMidjourneyTaskImageSeed(c *gin.Context) *dto.MidjourneyResponse {
+	taskId := c.Param("id")
+	userId := c.GetInt("id")
+	originTask := model.GetByMJId(userId, taskId)
+	if originTask == nil {
+		return service.MidjourneyErrorWrapper(constant.MjRequestError, "task_no_found")
+	}
+	channel, err := model.GetChannelById(originTask.ChannelId, true)
+	if err != nil {
+		return service.MidjourneyErrorWrapper(constant.MjRequestError, "get_channel_info_failed")
+	}
+	if channel.Status != common.ChannelStatusEnabled {
+		return service.MidjourneyErrorWrapper(constant.MjRequestError, "该任务所属渠道已被禁用")
+	}
+	c.Set("channel_id", originTask.ChannelId)
+	c.Request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", channel.Key))
+
+	requestURL := getMjRequestPath(c.Request.URL.String())
+	fullRequestURL := fmt.Sprintf("%s%s", channel.GetBaseURL(), requestURL)
+	midjResponseWithStatus, _, err := service.DoMidjourneyHttpRequest(c, time.Second*30, fullRequestURL)
+	if err != nil {
+		return &midjResponseWithStatus.Response
+	}
+	midjResponse := &midjResponseWithStatus.Response
+	c.Writer.WriteHeader(midjResponseWithStatus.StatusCode)
+	respBody, err := json.Marshal(midjResponse)
+	if err != nil {
+		return service.MidjourneyErrorWrapper(constant.MjRequestError, "unmarshal_response_body_failed")
+	}
+	_, err = io.Copy(c.Writer, bytes.NewBuffer(respBody))
+	if err != nil {
+		return service.MidjourneyErrorWrapper(constant.MjRequestError, "copy_response_body_failed")
+	}
+	return nil
+}
+
 func RelayMidjourneyTask(c *gin.Context, relayMode int) *dto.MidjourneyResponse {
 	userId := c.GetInt("id")
 	var err error
@@ -184,7 +295,7 @@ func RelayMidjourneyTask(c *gin.Context, relayMode int) *dto.MidjourneyResponse
 				Description: "task_no_found",
 			}
 		}
-		midjourneyTask := getMidjourneyTaskModel(c, originTask)
+		midjourneyTask := coverMidjourneyTaskDto(c, originTask)
 		respBody, err = json.Marshal(midjourneyTask)
 		if err != nil {
 			return &dto.MidjourneyResponse{
@@ -203,16 +314,16 @@ func RelayMidjourneyTask(c *gin.Context, relayMode int) *dto.MidjourneyResponse
 				Description: "do_request_failed",
 			}
 		}
-		var tasks []Midjourney
+		var tasks []dto.MidjourneyDto
 		if len(condition.IDs) != 0 {
 			originTasks := model.GetByMJIds(userId, condition.IDs)
 			for _, originTask := range originTasks {
-				midjourneyTask := getMidjourneyTaskModel(c, originTask)
+				midjourneyTask := coverMidjourneyTaskDto(c, originTask)
 				tasks = append(tasks, midjourneyTask)
 			}
 		}
 		if tasks == nil {
-			tasks = make([]Midjourney, 0)
+			tasks = make([]dto.MidjourneyDto, 0)
 		}
 		respBody, err = json.Marshal(tasks)
 		if err != nil {
@@ -235,170 +346,115 @@ func RelayMidjourneyTask(c *gin.Context, relayMode int) *dto.MidjourneyResponse
 	return nil
 }

-const (
-	// type 1 根据 mode 价格不同
-	MJSubmitActionImagine   = "IMAGINE"
-	MJSubmitActionVariation = "VARIATION" //变换
-	MJSubmitActionBlend     = "BLEND"     //混图
-
-	MJSubmitActionReroll = "REROLL" //重新生成
-	// type 2 固定价格
-	MJSubmitActionDescribe = "DESCRIBE"
-	MJSubmitActionUpscale  = "UPSCALE" // 放大
-)
-
 func RelayMidjourneySubmit(c *gin.Context, relayMode int) *dto.MidjourneyResponse {
-	imageModel := "midjourney"

 	tokenId := c.GetInt("token_id")
-	channelType := c.GetInt("channel")
+	//channelType := c.GetInt("channel")
 	userId := c.GetInt("id")
-	consumeQuota := c.GetBool("consume_quota")
 	group := c.GetString("group")
 	channelId := c.GetInt("channel_id")
+	consumeQuota := true
 	var midjRequest dto.MidjourneyRequest
-	if consumeQuota {
-		err := common.UnmarshalBodyReusable(c, &midjRequest)
-		if err != nil {
-			return &dto.MidjourneyResponse{
-				Code:        4,
-				Description: "bind_request_body_failed",
-			}
+	err := common.UnmarshalBodyReusable(c, &midjRequest)
+	if err != nil {
+		return service.MidjourneyErrorWrapper(constant.MjRequestError, "bind_request_body_failed")
+	}
+
+	if relayMode == relayconstant.RelayModeMidjourneyAction { // midjourney plus，需要从customId中获取任务信息
+		mjErr := service.CoverPlusActionToNormalAction(&midjRequest)
+		if mjErr != nil {
+			return mjErr
 		}
+		relayMode = relayconstant.RelayModeMidjourneyChange
 	}

 	if relayMode == relayconstant.RelayModeMidjourneyImagine { //绘画任务，此类任务可重复
 		if midjRequest.Prompt == "" {
-			return &dto.MidjourneyResponse{
-				Code:        4,
-				Description: "prompt_is_required",
-			}
+			return service.MidjourneyErrorWrapper(constant.MjRequestError, "prompt_is_required")
 		}
-		midjRequest.Action = "IMAGINE"
+		midjRequest.Action = constant.MjActionImagine
 	} else if relayMode == relayconstant.RelayModeMidjourneyDescribe { //按图生文任务，此类任务可重复
-		midjRequest.Action = "DESCRIBE"
+		midjRequest.Action = constant.MjActionDescribe
+	} else if relayMode == relayconstant.RelayModeMidjourneyShorten { //缩短任务，此类任务可重复，plus only
+		midjRequest.Action = constant.MjActionShorten
 	} else if relayMode == relayconstant.RelayModeMidjourneyBlend { //绘画任务，此类任务可重复
-		midjRequest.Action = "BLEND"
+		midjRequest.Action = constant.MjActionBlend
 	} else if midjRequest.TaskId != "" { //放大、变换任务，此类任务，如果重复且已有结果，远端api会直接返回最终结果
 		mjId := ""
 		if relayMode == relayconstant.RelayModeMidjourneyChange {
 			if midjRequest.TaskId == "" {
-				return &dto.MidjourneyResponse{
-					Code:        4,
-					Description: "taskId_is_required",
-				}
+				return service.MidjourneyErrorWrapper(constant.MjRequestError, "task_id_is_required")
 			} else if midjRequest.Action == "" {
-				return &dto.MidjourneyResponse{
-					Code:        4,
-					Description: "action_is_required",
-				}
+				return service.MidjourneyErrorWrapper(constant.MjRequestError, "action_is_required")
 			} else if midjRequest.Index == 0 {
-				return &dto.MidjourneyResponse{
-					Code:        4,
-					Description: "index_can_only_be_1_2_3_4",
-				}
+				return service.MidjourneyErrorWrapper(constant.MjRequestError, "index_is_required")
 			}
 			//action = midjRequest.Action
 			mjId = midjRequest.TaskId
 		} else if relayMode == relayconstant.RelayModeMidjourneySimpleChange {
 			if midjRequest.Content == "" {
-				return &dto.MidjourneyResponse{
-					Code:        4,
-					Description: "content_is_required",
-				}
+				return service.MidjourneyErrorWrapper(constant.MjRequestError, "content_is_required")
 			}
-			params := convertSimpleChangeParams(midjRequest.Content)
+			params := service.ConvertSimpleChangeParams(midjRequest.Content)
 			if params == nil {
-				return &dto.MidjourneyResponse{
-					Code:        4,
-					Description: "content_parse_failed",
-				}
+				return service.MidjourneyErrorWrapper(constant.MjRequestError, "content_parse_failed")
 			}
-			mjId = params.ID
+			mjId = params.TaskId
 			midjRequest.Action = params.Action
+		} else if relayMode == relayconstant.RelayModeMidjourneyModal {
+			//if midjRequest.MaskBase64 == "" {
+			//	return service.MidjourneyErrorWrapper(constant.MjRequestError, "mask_base64_is_required")
+			//}
+			mjId = midjRequest.TaskId
+			midjRequest.Action = constant.MjActionModal
 		}

 		originTask := model.GetByMJId(userId, mjId)
 		if originTask == nil {
-			return &dto.MidjourneyResponse{
-				Code:        4,
-				Description: "task_no_found",
-			}
-		} else if originTask.Action == "UPSCALE" {
-			//return errorWrapper(errors.New("upscale task can not be change"), "request_params_error", http.StatusBadRequest).
-			return &dto.MidjourneyResponse{
-				Code:        4,
-				Description: "upscale_task_can_not_be_change",
-			}
-		} else if originTask.Status != "SUCCESS" {
-			return &dto.MidjourneyResponse{
-				Code:        4,
-				Description: "task_status_is_not_success",
-			}
+			return service.MidjourneyErrorWrapper(constant.MjRequestError, "task_not_found")
+		} else if originTask.Status != "SUCCESS" && relayMode != relayconstant.RelayModeMidjourneyModal {
+			return service.MidjourneyErrorWrapper(constant.MjRequestError, "task_status_not_success")
 		} else { //原任务的Status=SUCCESS，则可以做放大UPSCALE、变换VARIATION等动作，此时必须使用原来的请求地址才能正确处理
-			channel, err := model.GetChannelById(originTask.ChannelId, false)
+			channel, err := model.GetChannelById(originTask.ChannelId, true)
 			if err != nil {
-				return &dto.MidjourneyResponse{
-					Code:        4,
-					Description: "channel_not_found",
-				}
+				return service.MidjourneyErrorWrapper(constant.MjRequestError, "get_channel_info_failed")
+			}
+			if channel.Status != common.ChannelStatusEnabled {
+				return service.MidjourneyErrorWrapper(constant.MjRequestError, "该任务所属渠道已被禁用")
 			}
 			c.Set("base_url", channel.GetBaseURL())
 			c.Set("channel_id", originTask.ChannelId)
-			log.Printf("检测到此操作为放大、变换，获取原channel信息: %s,%s", strconv.Itoa(originTask.ChannelId), channel.GetBaseURL())
+			c.Request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", channel.Key))
+			log.Printf("检测到此操作为放大、变换、重绘，获取原channel信息: %s,%s", strconv.Itoa(originTask.ChannelId), channel.GetBaseURL())
 		}
 		midjRequest.Prompt = originTask.Prompt
+
+		//if channelType == common.ChannelTypeMidjourneyPlus {
+		//	// plus
+		//} else {
+		//	// 普通版渠道
+		//
+		//}
 	}

-	// map model name
-	modelMapping := c.GetString("model_mapping")
-	isModelMapped := false
-	if modelMapping != "" {
-		modelMap := make(map[string]string)
-		err := json.Unmarshal([]byte(modelMapping), &modelMap)
-		if err != nil {
-			//return errorWrapper(err, "unmarshal_model_mapping_failed", http.StatusInternalServerError)
-			return &dto.MidjourneyResponse{
-				Code:        4,
-				Description: "unmarshal_model_mapping_failed",
-			}
-		}
-		if modelMap[imageModel] != "" {
-			imageModel = modelMap[imageModel]
-			isModelMapped = true
-		}
+	if midjRequest.Action == constant.MjActionInPaint || midjRequest.Action == constant.MjActionCustomZoom {
+		consumeQuota = false
 	}

-	baseURL := common.ChannelBaseURLs[channelType]
-	requestURL := c.Request.URL.String()
+	//baseURL := common.ChannelBaseURLs[channelType]
+	requestURL := getMjRequestPath(c.Request.URL.String())

-	if c.GetString("base_url") != "" {
-		baseURL = c.GetString("base_url")
-	}
+	baseURL := c.GetString("base_url")

 	//midjRequest.NotifyHook = "http://127.0.0.1:3000/mj/notify"

 	fullRequestURL := fmt.Sprintf("%s%s", baseURL, requestURL)
-	log.Printf("fullRequestURL: %s", fullRequestURL)

-	var requestBody io.Reader
-	if isModelMapped {
-		jsonStr, err := json.Marshal(midjRequest)
-		if err != nil {
-			return &dto.MidjourneyResponse{
-				Code:        4,
-				Description: "marshal_text_request_failed",
-			}
-		}
-		requestBody = bytes.NewBuffer(jsonStr)
-	} else {
-		requestBody = c.Request.Body
-	}
-	mjAction := "mj_" + strings.ToLower(midjRequest.Action)
-	modelPrice := common.GetModelPrice(mjAction, true)
+	modelName := service.CoverActionToModelName(midjRequest.Action)
+	modelPrice := common.GetModelPrice(modelName, true)
 	// 如果没有配置价格，则使用默认价格
 	if modelPrice == -1 {
-		defaultPrice, ok := DefaultModelPrice[mjAction]
+		defaultPrice, ok := common.DefaultModelPrice[modelName]
 		if !ok {
 			modelPrice = 0.1
 		} else {
@@ -423,53 +479,14 @@ func RelayMidjourneySubmit(c *gin.Context, relayMode int) *dto.MidjourneyRespons
 		}
 	}

-	req, err := http.NewRequest(c.Request.Method, fullRequestURL, requestBody)
+	midjResponseWithStatus, responseBody, err := service.DoMidjourneyHttpRequest(c, time.Second*60, fullRequestURL)
 	if err != nil {
-		return &dto.MidjourneyResponse{
-			Code:        4,
-			Description: "create_request_failed",
-		}
+		return &midjResponseWithStatus.Response
 	}
-	//req.Header.Set("ApiKey", c.Request.Header.Get("ApiKey"))
-
-	req.Header.Set("Content-Type", c.Request.Header.Get("Content-Type"))
-	req.Header.Set("Accept", c.Request.Header.Get("Accept"))
-	//mjToken := ""
-	//if c.Request.Header.Get("ApiKey") != "" {
-	//	mjToken = strings.Split(c.Request.Header.Get("ApiKey"), " ")[1]
-	//}
-	//req.Header.Set("ApiKey", "Bearer midjourney-proxy")
-	req.Header.Set("mj-api-secret", strings.Split(c.Request.Header.Get("Authorization"), " ")[1])
-	// print request header
-	log.Printf("request header: %s", req.Header)
-	log.Printf("request body: %s", midjRequest.Prompt)
-
-	resp, err := service.GetHttpClient().Do(req)
-	if err != nil {
-		return &dto.MidjourneyResponse{
-			Code:        4,
-			Description: "do_request_failed",
-		}
-	}
-
-	err = req.Body.Close()
-	if err != nil {
-		return &dto.MidjourneyResponse{
-			Code:        4,
-			Description: "close_request_body_failed",
-		}
-	}
-	err = c.Request.Body.Close()
-	if err != nil {
-		return &dto.MidjourneyResponse{
-			Code:        4,
-			Description: "close_request_body_failed",
-		}
-	}
-	var midjResponse dto.MidjourneyResponse
+	midjResponse := &midjResponseWithStatus.Response

 	defer func(ctx context.Context) {
-		if consumeQuota {
+		if consumeQuota && midjResponseWithStatus.StatusCode == 200 {
 			err := model.PostConsumeTokenQuota(tokenId, userQuota, quota, 0, true)
 			if err != nil {
 				common.SysError("error consuming token remain quota: " + err.Error())
@@ -481,7 +498,7 @@ func RelayMidjourneySubmit(c *gin.Context, relayMode int) *dto.MidjourneyRespons
 			if quota != 0 {
 				tokenName := c.GetString("token_name")
 				logContent := fmt.Sprintf("模型固定价格 %.2f，分组倍率 %.2f，操作 %s", modelPrice, groupRatio, midjRequest.Action)
-				model.RecordConsumeLog(ctx, userId, channelId, 0, 0, imageModel, tokenName, quota, logContent, tokenId, userQuota, 0, false)
+				model.RecordConsumeLog(ctx, userId, channelId, 0, 0, modelName, tokenName, quota, logContent, tokenId, userQuota, 0, false)
 				model.UpdateUserUsedQuotaAndRequestCount(userId, quota)
 				channelId := c.GetInt("channel_id")
 				model.UpdateChannelUsedQuota(channelId, quota)
@@ -489,41 +506,6 @@ func RelayMidjourneySubmit(c *gin.Context, relayMode int) *dto.MidjourneyRespons
 		}
 	}(c.Request.Context())

-	//if consumeQuota {
-	//
-	//}
-	responseBody, err := io.ReadAll(resp.Body)
-
-	if err != nil {
-		return &dto.MidjourneyResponse{
-			Code:        4,
-			Description: "read_response_body_failed",
-		}
-	}
-	err = resp.Body.Close()
-	if err != nil {
-		return &dto.MidjourneyResponse{
-			Code:        4,
-			Description: "close_response_body_failed",
-		}
-	}
-
-	err = json.Unmarshal(responseBody, &midjResponse)
-	log.Printf("responseBody: %s", string(responseBody))
-	log.Printf("midjResponse: %v", midjResponse)
-	if resp.StatusCode != 200 {
-		return &dto.MidjourneyResponse{
-			Code:        4,
-			Description: "fail_to_fetch_midjourney status_code: " + strconv.Itoa(resp.StatusCode),
-		}
-	}
-	if err != nil {
-		return &dto.MidjourneyResponse{
-			Code:        4,
-			Description: "unmarshal_response_body_failed",
-		}
-	}
-
 	// 文档：https://github.com/novicezk/midjourney-proxy/blob/main/docs/api.md
 	//1-提交成功
 	// 21-任务已存在（处理中或者有结果了） {"code":21,"description":"任务已存在","result":"0741798445574458","properties":{"status":"SUCCESS","imageUrl":"https://xxxx"}}
@@ -575,8 +557,10 @@ func RelayMidjourneySubmit(c *gin.Context, relayMode int) *dto.MidjourneyRespons
 			}
 		}
 		//修改返回值
-		newBody := strings.Replace(string(responseBody), `"code":21`, `"code":1`, -1)
-		responseBody = []byte(newBody)
+		if midjRequest.Action != constant.MjActionInPaint && midjRequest.Action != constant.MjActionCustomZoom {
+			newBody := strings.Replace(string(responseBody), `"code":21`, `"code":1`, -1)
+			responseBody = []byte(newBody)
+		}
 	}

 	err = midjourneyTask.Insert()
@@ -593,21 +577,22 @@ func RelayMidjourneySubmit(c *gin.Context, relayMode int) *dto.MidjourneyRespons
 		responseBody = []byte(newBody)
 	}

-	resp.Body = io.NopCloser(bytes.NewBuffer(responseBody))
+	//resp.Body = io.NopCloser(bytes.NewBuffer(responseBody))
+	bodyReader := io.NopCloser(bytes.NewBuffer(responseBody))

-	for k, v := range resp.Header {
-		c.Writer.Header().Set(k, v[0])
-	}
-	c.Writer.WriteHeader(resp.StatusCode)
+	//for k, v := range resp.Header {
+	//	c.Writer.Header().Set(k, v[0])
+	//}
+	c.Writer.WriteHeader(midjResponseWithStatus.StatusCode)

-	_, err = io.Copy(c.Writer, resp.Body)
+	_, err = io.Copy(c.Writer, bodyReader)
 	if err != nil {
 		return &dto.MidjourneyResponse{
 			Code:        4,
 			Description: "copy_response_body_failed",
 		}
 	}
-	err = resp.Body.Close()
+	err = bodyReader.Close()
 	if err != nil {
 		return &dto.MidjourneyResponse{
 			Code:        4,
@@ -623,31 +608,14 @@ type taskChangeParams struct {
 	Index  int
 }

-func convertSimpleChangeParams(content string) *taskChangeParams {
-	split := strings.Split(content, " ")
-	if len(split) != 2 {
-		return nil
+func getMjRequestPath(path string) string {
+	requestURL := path
+	if strings.Contains(requestURL, "/mj-") {
+		urls := strings.Split(requestURL, "/mj/")
+		if len(urls) < 2 {
+			return requestURL
+		}
+		requestURL = "/mj/" + urls[1]
 	}
-
-	action := strings.ToLower(split[1])
-	changeParams := &taskChangeParams{}
-	changeParams.ID = split[0]
-
-	if action[0] == 'u' {
-		changeParams.Action = "UPSCALE"
-	} else if action[0] == 'v' {
-		changeParams.Action = "VARIATION"
-	} else if action == "r" {
-		changeParams.Action = "REROLL"
-		return changeParams
-	} else {
-		return nil
-	}
-
-	index, err := strconv.Atoi(action[1:2])
-	if err != nil || index < 1 || index > 4 {
-		return nil
-	}
-	changeParams.Index = index
-	return changeParams
+	return requestURL
 }
--- a/relay/relay-text.go
+++ b/relay/relay-text.go
@@ -10,6 +10,7 @@ import (
 	"math"
 	"net/http"
 	"one-api/common"
+	"one-api/constant"
 	"one-api/dto"
 	"one-api/model"
 	relaycommon "one-api/relay/common"
@@ -60,7 +61,6 @@ func getAndValidateTextRequest(c *gin.Context, relayInfo *relaycommon.RelayInfo)
 		}
 	}
 	relayInfo.IsStream = textRequest.Stream
-	relayInfo.UpstreamModelName = textRequest.Model
 	return textRequest, nil
 }

@@ -72,7 +72,7 @@ func TextHelper(c *gin.Context) *dto.OpenAIErrorWithStatusCode {
 	textRequest, err := getAndValidateTextRequest(c, relayInfo)
 	if err != nil {
 		common.LogError(c, fmt.Sprintf("getAndValidateTextRequest failed: %s", err.Error()))
-		return service.OpenAIErrorWrapper(err, "invalid_text_request", http.StatusBadRequest)
+		return service.OpenAIErrorWrapperLocal(err, "invalid_text_request", http.StatusBadRequest)
 	}

 	// map model name
@@ -82,23 +82,29 @@ func TextHelper(c *gin.Context) *dto.OpenAIErrorWithStatusCode {
 		modelMap := make(map[string]string)
 		err := json.Unmarshal([]byte(modelMapping), &modelMap)
 		if err != nil {
-			return service.OpenAIErrorWrapper(err, "unmarshal_model_mapping_failed", http.StatusInternalServerError)
+			return service.OpenAIErrorWrapperLocal(err, "unmarshal_model_mapping_failed", http.StatusInternalServerError)
 		}
 		if modelMap[textRequest.Model] != "" {
 			textRequest.Model = modelMap[textRequest.Model]
+			// set upstream model name
 			isModelMapped = true
 		}
 	}
+	relayInfo.UpstreamModelName = textRequest.Model
 	modelPrice := common.GetModelPrice(textRequest.Model, false)
 	groupRatio := common.GetGroupRatio(relayInfo.Group)

 	var preConsumedQuota int
 	var ratio float64
 	var modelRatio float64
-	promptTokens, err := getPromptTokens(textRequest, relayInfo)
+	//err := service.SensitiveWordsCheck(textRequest)
+	promptTokens, err, sensitiveTrigger := getPromptTokens(textRequest, relayInfo)

 	// count messages token error 计算promptTokens错误
 	if err != nil {
+		if sensitiveTrigger {
+			return service.OpenAIErrorWrapperLocal(err, "sensitive_words_detected", http.StatusBadRequest)
+		}
 		return service.OpenAIErrorWrapper(err, "count_token_messages_failed", http.StatusInternalServerError)
 	}

@@ -148,59 +154,68 @@ func TextHelper(c *gin.Context) *dto.OpenAIErrorWithStatusCode {
 		requestBody = bytes.NewBuffer(jsonData)
 	}

+	statusCodeMappingStr := c.GetString("status_code_mapping")
 	resp, err := adaptor.DoRequest(c, relayInfo, requestBody)
 	if err != nil {
 		return service.OpenAIErrorWrapper(err, "do_request_failed", http.StatusInternalServerError)
 	}
-	relayInfo.IsStream = relayInfo.IsStream || strings.HasPrefix(resp.Header.Get("Content-Type"), "text/event-stream")

-	if resp.StatusCode != http.StatusOK {
-		returnPreConsumedQuota(c, relayInfo.TokenId, userQuota, preConsumedQuota)
-		return service.RelayErrorHandler(resp)
+	if resp != nil {
+		relayInfo.IsStream = relayInfo.IsStream || strings.HasPrefix(resp.Header.Get("Content-Type"), "text/event-stream")
+		if resp.StatusCode != http.StatusOK {
+			returnPreConsumedQuota(c, relayInfo.TokenId, userQuota, preConsumedQuota)
+			openaiErr := service.RelayErrorHandler(resp)
+			// reset status code 重置状态码
+			service.ResetStatusCode(openaiErr, statusCodeMappingStr)
+			return openaiErr
+		}
 	}

 	usage, openaiErr := adaptor.DoResponse(c, resp, relayInfo)
 	if openaiErr != nil {
 		returnPreConsumedQuota(c, relayInfo.TokenId, userQuota, preConsumedQuota)
+		// reset status code 重置状态码
+		service.ResetStatusCode(openaiErr, statusCodeMappingStr)
 		return openaiErr
 	}
 	postConsumeQuota(c, relayInfo, *textRequest, usage, ratio, preConsumedQuota, userQuota, modelRatio, groupRatio, modelPrice)
 	return nil
 }

-func getPromptTokens(textRequest *dto.GeneralOpenAIRequest, info *relaycommon.RelayInfo) (int, error) {
+func getPromptTokens(textRequest *dto.GeneralOpenAIRequest, info *relaycommon.RelayInfo) (int, error, bool) {
 	var promptTokens int
 	var err error
-
+	var sensitiveTrigger bool
+	checkSensitive := constant.ShouldCheckPromptSensitive()
 	switch info.RelayMode {
 	case relayconstant.RelayModeChatCompletions:
-		promptTokens, err = service.CountTokenMessages(textRequest.Messages, textRequest.Model)
+		promptTokens, err, sensitiveTrigger = service.CountTokenMessages(textRequest.Messages, textRequest.Model, checkSensitive)
 	case relayconstant.RelayModeCompletions:
-		promptTokens, err = service.CountTokenInput(textRequest.Prompt, textRequest.Model), nil
+		promptTokens, err, sensitiveTrigger = service.CountTokenInput(textRequest.Prompt, textRequest.Model, checkSensitive)
 	case relayconstant.RelayModeModerations:
-		promptTokens, err = service.CountTokenInput(textRequest.Input, textRequest.Model), nil
+		promptTokens, err, sensitiveTrigger = service.CountTokenInput(textRequest.Input, textRequest.Model, checkSensitive)
 	case relayconstant.RelayModeEmbeddings:
-		promptTokens, err = service.CountTokenInput(textRequest.Input, textRequest.Model), nil
+		promptTokens, err, sensitiveTrigger = service.CountTokenInput(textRequest.Input, textRequest.Model, checkSensitive)
 	default:
 		err = errors.New("unknown relay mode")
 		promptTokens = 0
 	}
 	info.PromptTokens = promptTokens
-	return promptTokens, err
+	return promptTokens, err, sensitiveTrigger
 }

 // 预扣费并返回用户剩余配额
 func preConsumeQuota(c *gin.Context, preConsumedQuota int, relayInfo *relaycommon.RelayInfo) (int, int, *dto.OpenAIErrorWithStatusCode) {
 	userQuota, err := model.CacheGetUserQuota(relayInfo.UserId)
 	if err != nil {
-		return 0, 0, service.OpenAIErrorWrapper(err, "get_user_quota_failed", http.StatusInternalServerError)
+		return 0, 0, service.OpenAIErrorWrapperLocal(err, "get_user_quota_failed", http.StatusInternalServerError)
 	}
 	if userQuota <= 0 || userQuota-preConsumedQuota < 0 {
-		return 0, 0, service.OpenAIErrorWrapper(errors.New("user quota is not enough"), "insufficient_user_quota", http.StatusForbidden)
+		return 0, 0, service.OpenAIErrorWrapperLocal(errors.New("user quota is not enough"), "insufficient_user_quota", http.StatusForbidden)
 	}
 	err = model.CacheDecreaseUserQuota(relayInfo.UserId, preConsumedQuota)
 	if err != nil {
-		return 0, 0, service.OpenAIErrorWrapper(err, "decrease_user_quota_failed", http.StatusInternalServerError)
+		return 0, 0, service.OpenAIErrorWrapperLocal(err, "decrease_user_quota_failed", http.StatusInternalServerError)
 	}
 	if userQuota > 100*preConsumedQuota {
 		// 用户额度充足，判断令牌额度是否充足
@@ -222,7 +237,7 @@ func preConsumeQuota(c *gin.Context, preConsumedQuota int, relayInfo *relaycommo
 	if preConsumedQuota > 0 {
 		userQuota, err = model.PreConsumeTokenQuota(relayInfo.TokenId, preConsumedQuota)
 		if err != nil {
-			return 0, 0, service.OpenAIErrorWrapper(err, "pre_consume_token_quota_failed", http.StatusForbidden)
+			return 0, 0, service.OpenAIErrorWrapperLocal(err, "pre_consume_token_quota_failed", http.StatusForbidden)
 		}
 	}
 	return preConsumedQuota, userQuota, nil
@@ -240,7 +255,10 @@ func returnPreConsumedQuota(c *gin.Context, tokenId int, userQuota int, preConsu
 	}
 }

-func postConsumeQuota(ctx *gin.Context, relayInfo *relaycommon.RelayInfo, textRequest dto.GeneralOpenAIRequest, usage *dto.Usage, ratio float64, preConsumedQuota int, userQuota int, modelRatio float64, groupRatio float64, modelPrice float64) {
+func postConsumeQuota(ctx *gin.Context, relayInfo *relaycommon.RelayInfo, textRequest dto.GeneralOpenAIRequest,
+	usage *dto.Usage, ratio float64, preConsumedQuota int, userQuota int, modelRatio float64, groupRatio float64,
+	modelPrice float64) {
+
 	useTimeSeconds := time.Now().Unix() - relayInfo.StartTime.Unix()
 	promptTokens := usage.PromptTokens
 	completionTokens := usage.CompletionTokens
@@ -274,12 +292,17 @@ func postConsumeQuota(ctx *gin.Context, relayInfo *relaycommon.RelayInfo, textRe
 		logContent += fmt.Sprintf("（可能是上游超时）")
 		common.LogError(ctx, fmt.Sprintf("total tokens is 0, cannot consume quota, userId %d, channelId %d, tokenId %d, model %s， pre-consumed quota %d", relayInfo.UserId, relayInfo.ChannelId, relayInfo.TokenId, textRequest.Model, preConsumedQuota))
 	} else {
+		//if sensitiveResp != nil {
+		//	logContent += fmt.Sprintf("，敏感词：%s", strings.Join(sensitiveResp.SensitiveWords, ", "))
+		//}
 		quotaDelta := quota - preConsumedQuota
-		err := model.PostConsumeTokenQuota(relayInfo.TokenId, userQuota, quotaDelta, preConsumedQuota, true)
-		if err != nil {
-			common.LogError(ctx, "error consuming token remain quota: "+err.Error())
+		if quotaDelta != 0 {
+			err := model.PostConsumeTokenQuota(relayInfo.TokenId, userQuota, quotaDelta, preConsumedQuota, true)
+			if err != nil {
+				common.LogError(ctx, "error consuming token remain quota: "+err.Error())
+			}
 		}
-		err = model.CacheUpdateUserQuota(relayInfo.UserId)
+		err := model.CacheUpdateUserQuota(relayInfo.UserId)
 		if err != nil {
 			common.LogError(ctx, "error update user quota cache: "+err.Error())
 		}
--- a/relay/relay_adaptor.go
+++ b/relay/relay_adaptor.go
@@ -3,11 +3,14 @@ package relay
 import (
 	"one-api/relay/channel"
 	"one-api/relay/channel/ali"
+	"one-api/relay/channel/aws"
 	"one-api/relay/channel/baidu"
 	"one-api/relay/channel/claude"
 	"one-api/relay/channel/gemini"
+	"one-api/relay/channel/ollama"
 	"one-api/relay/channel/openai"
 	"one-api/relay/channel/palm"
+	"one-api/relay/channel/perplexity"
 	"one-api/relay/channel/tencent"
 	"one-api/relay/channel/xunfei"
 	"one-api/relay/channel/zhipu"
@@ -39,6 +42,12 @@ func GetAdaptor(apiType int) channel.Adaptor {
 		return &zhipu.Adaptor{}
 	case constant.APITypeZhipu_v4:
 		return &zhipu_4v.Adaptor{}
+	case constant.APITypeOllama:
+		return &ollama.Adaptor{}
+	case constant.APITypePerplexity:
+		return &perplexity.Adaptor{}
+	case constant.APITypeAws:
+		return &aws.Adaptor{}
 	}
 	return nil
 }
--- a/router/api-router.go
+++ b/router/api-router.go
@@ -17,7 +17,7 @@ func SetApiRouter(router *gin.Engine) {
 		apiRouter.GET("/status/test", middleware.AdminAuth(), controller.TestStatus)
 		apiRouter.GET("/notice", controller.GetNotice)
 		apiRouter.GET("/about", controller.GetAbout)
-		apiRouter.GET("/midjourney", controller.GetMidjourney)
+		//apiRouter.GET("/midjourney", controller.GetMidjourney)
 		apiRouter.GET("/home_page_content", controller.GetHomePageContent)
 		apiRouter.GET("/verification", middleware.CriticalRateLimit(), middleware.TurnstileCheck(), controller.SendEmailVerification)
 		apiRouter.GET("/reset_password", middleware.CriticalRateLimit(), middleware.TurnstileCheck(), controller.SendPasswordResetEmail)
--- a/router/relay-router.go
+++ b/router/relay-router.go
@@ -43,10 +43,22 @@ func SetRelayRouter(router *gin.Engine) {
 		relayV1Router.DELETE("/models/:model", controller.RelayNotImplemented)
 		relayV1Router.POST("/moderations", controller.Relay)
 	}
+
 	relayMjRouter := router.Group("/mj")
+	registerMjRouterGroup(relayMjRouter)
+
+	relayMjModeRouter := router.Group("/:mode/mj")
+	registerMjRouterGroup(relayMjModeRouter)
+	//relayMjRouter.Use()
+}
+
+func registerMjRouterGroup(relayMjRouter *gin.RouterGroup) {
 	relayMjRouter.GET("/image/:id", relay.RelayMidjourneyImage)
 	relayMjRouter.Use(middleware.TokenAuth(), middleware.Distribute())
 	{
+		relayMjRouter.POST("/submit/action", controller.RelayMidjourney)
+		relayMjRouter.POST("/submit/shorten", controller.RelayMidjourney)
+		relayMjRouter.POST("/submit/modal", controller.RelayMidjourney)
 		relayMjRouter.POST("/submit/imagine", controller.RelayMidjourney)
 		relayMjRouter.POST("/submit/change", controller.RelayMidjourney)
 		relayMjRouter.POST("/submit/simple-change", controller.RelayMidjourney)
@@ -54,7 +66,8 @@ func SetRelayRouter(router *gin.Engine) {
 		relayMjRouter.POST("/submit/blend", controller.RelayMidjourney)
 		relayMjRouter.POST("/notify", controller.RelayMidjourney)
 		relayMjRouter.GET("/task/:id/fetch", controller.RelayMidjourney)
+		relayMjRouter.GET("/task/:id/image-seed", controller.RelayMidjourney)
 		relayMjRouter.POST("/task/list-by-condition", controller.RelayMidjourney)
+		relayMjRouter.POST("/insight-face/swap", controller.RelayMidjourney)
 	}
-	//relayMjRouter.Use()
 }
--- a/router/web-router.go
+++ b/router/web-router.go
@@ -16,9 +16,9 @@ func SetWebRouter(router *gin.Engine, buildFS embed.FS, indexPage []byte) {
 	router.Use(gzip.Gzip(gzip.DefaultCompression))
 	router.Use(middleware.GlobalWebRateLimit())
 	router.Use(middleware.Cache())
-	router.Use(static.Serve("/", common.EmbedFolder(buildFS, "web/build")))
+	router.Use(static.Serve("/", common.EmbedFolder(buildFS, "web/dist")))
 	router.NoRoute(func(c *gin.Context) {
-		if strings.HasPrefix(c.Request.RequestURI, "/v1") || strings.HasPrefix(c.Request.RequestURI, "/api") {
+		if strings.HasPrefix(c.Request.RequestURI, "/v1") || strings.HasPrefix(c.Request.RequestURI, "/api") || strings.HasPrefix(c.Request.RequestURI, "/assets") {
 			controller.RelayNotFound(c)
 			return
 		}
--- a/service/channel.go
+++ b/service/channel.go
@@ -6,6 +6,7 @@ import (
 	"one-api/common"
 	relaymodel "one-api/dto"
 	"one-api/model"
+	"strings"
 )

 // disable & notify
@@ -33,7 +34,30 @@ func ShouldDisableChannel(err *relaymodel.OpenAIError, statusCode int) bool {
 	if statusCode == http.StatusUnauthorized {
 		return true
 	}
-	if err.Type == "insufficient_quota" || err.Code == "invalid_api_key" || err.Code == "account_deactivated" || err.Code == "billing_not_active" {
+	switch err.Code {
+	case "invalid_api_key":
+		return true
+	case "account_deactivated":
+		return true
+	case "billing_not_active":
+		return true
+	}
+	switch err.Type {
+	case "insufficient_quota":
+		return true
+	// https://docs.anthropic.com/claude/reference/errors
+	case "authentication_error":
+		return true
+	case "permission_error":
+		return true
+	case "forbidden":
+		return true
+	}
+	if strings.HasPrefix(err.Message, "Your credit balance is too low") { // anthropic
+		return true
+	} else if strings.HasPrefix(err.Message, "This organization has been disabled.") {
+		return true
+	} else if strings.HasPrefix(err.Message, "You exceeded your current quota") {
 		return true
 	}
 	return false
--- a/service/epay.go
+++ b/service/epay.go
@@ -1,10 +1,13 @@
 package service

-import "one-api/common"
+import (
+	"one-api/common"
+	"one-api/constant"
+)

 func GetCallbackAddress() string {
-	if common.CustomCallbackAddress == "" {
+	if constant.CustomCallbackAddress == "" {
 		return common.ServerAddress
 	}
-	return common.CustomCallbackAddress
+	return constant.CustomCallbackAddress
 }
--- a/service/error.go
+++ b/service/error.go
@@ -11,11 +11,25 @@ import (
 	"strings"
 )

+func MidjourneyErrorWrapper(code int, desc string) *dto.MidjourneyResponse {
+	return &dto.MidjourneyResponse{
+		Code:        code,
+		Description: desc,
+	}
+}
+
+func MidjourneyErrorWithStatusCodeWrapper(code int, desc string, statusCode int) *dto.MidjourneyResponseWithStatusCode {
+	return &dto.MidjourneyResponseWithStatusCode{
+		StatusCode: statusCode,
+		Response:   *MidjourneyErrorWrapper(code, desc),
+	}
+}
+
 // OpenAIErrorWrapper wraps an error into an OpenAIErrorWithStatusCode
 func OpenAIErrorWrapper(err error, code string, statusCode int) *dto.OpenAIErrorWithStatusCode {
 	text := err.Error()
 	// 定义一个正则表达式匹配URL
-	if strings.Contains(text, "Post") {
+	if strings.Contains(text, "Post") || strings.Contains(text, "dial") {
 		common.SysLog(fmt.Sprintf("error: %s", text))
 		text = "请求上游地址失败"
 	}
@@ -32,6 +46,12 @@ func OpenAIErrorWrapper(err error, code string, statusCode int) *dto.OpenAIError
 	}
 }

+func OpenAIErrorWrapperLocal(err error, code string, statusCode int) *dto.OpenAIErrorWithStatusCode {
+	openaiErr := OpenAIErrorWrapper(err, code, statusCode)
+	openaiErr.LocalError = true
+	return openaiErr
+}
+
 func RelayErrorHandler(resp *http.Response) (errWithStatusCode *dto.OpenAIErrorWithStatusCode) {
 	errWithStatusCode = &dto.OpenAIErrorWithStatusCode{
 		StatusCode: resp.StatusCode,
@@ -66,3 +86,22 @@ func RelayErrorHandler(resp *http.Response) (errWithStatusCode *dto.OpenAIErrorW
 	}
 	return
 }
+
+func ResetStatusCode(openaiErr *dto.OpenAIErrorWithStatusCode, statusCodeMappingStr string) {
+	if statusCodeMappingStr == "" || statusCodeMappingStr == "{}" {
+		return
+	}
+	statusCodeMapping := make(map[string]string)
+	err := json.Unmarshal([]byte(statusCodeMappingStr), &statusCodeMapping)
+	if err != nil {
+		return
+	}
+	if openaiErr.StatusCode == http.StatusOK {
+		return
+	}
+	codeStr := strconv.Itoa(openaiErr.StatusCode)
+	if _, ok := statusCodeMapping[codeStr]; ok {
+		intCode, _ := strconv.Atoi(statusCodeMapping[codeStr])
+		openaiErr.StatusCode = intCode
+	}
+}
--- a/service/midjourney.go
+++ b/service/midjourney.go
@@ -0,0 +1,248 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"github.com/gin-gonic/gin"
+	"io"
+	"log"
+	"net/http"
+	"one-api/common"
+	"one-api/constant"
+	"one-api/dto"
+	relayconstant "one-api/relay/constant"
+	"strconv"
+	"strings"
+	"time"
+)
+
+func CoverActionToModelName(mjAction string) string {
+	modelName := "mj_" + strings.ToLower(mjAction)
+	if mjAction == constant.MjActionSwapFace {
+		modelName = "swap_face"
+	}
+	return modelName
+}
+
+func GetMjRequestModel(relayMode int, midjRequest *dto.MidjourneyRequest) (string, *dto.MidjourneyResponse, bool) {
+	action := ""
+	if relayMode == relayconstant.RelayModeMidjourneyAction {
+		// plus request
+		err := CoverPlusActionToNormalAction(midjRequest)
+		if err != nil {
+			return "", err, false
+		}
+		action = midjRequest.Action
+	} else {
+		switch relayMode {
+		case relayconstant.RelayModeMidjourneyImagine:
+			action = constant.MjActionImagine
+		case relayconstant.RelayModeMidjourneyDescribe:
+			action = constant.MjActionDescribe
+		case relayconstant.RelayModeMidjourneyBlend:
+			action = constant.MjActionBlend
+		case relayconstant.RelayModeMidjourneyShorten:
+			action = constant.MjActionShorten
+		case relayconstant.RelayModeMidjourneyChange:
+			action = midjRequest.Action
+		case relayconstant.RelayModeMidjourneyModal:
+			action = constant.MjActionModal
+		case relayconstant.RelayModeSwapFace:
+			action = constant.MjActionSwapFace
+		case relayconstant.RelayModeMidjourneySimpleChange:
+			params := ConvertSimpleChangeParams(midjRequest.Content)
+			if params == nil {
+				return "", MidjourneyErrorWrapper(constant.MjRequestError, "invalid_request"), false
+			}
+			action = params.Action
+		case relayconstant.RelayModeMidjourneyTaskFetch, relayconstant.RelayModeMidjourneyTaskFetchByCondition, relayconstant.RelayModeMidjourneyNotify:
+			return "", nil, true
+		default:
+			return "", MidjourneyErrorWrapper(constant.MjRequestError, "unknown_relay_action"), false
+		}
+	}
+	modelName := CoverActionToModelName(action)
+	return modelName, nil, true
+}
+
+func CoverPlusActionToNormalAction(midjRequest *dto.MidjourneyRequest) *dto.MidjourneyResponse {
+	// "customId": "MJ::JOB::upsample::2::3dbbd469-36af-4a0f-8f02-df6c579e7011"
+	customId := midjRequest.CustomId
+	if customId == "" {
+		return MidjourneyErrorWrapper(constant.MjRequestError, "custom_id_is_required")
+	}
+	splits := strings.Split(customId, "::")
+	var action string
+	if splits[1] == "JOB" {
+		action = splits[2]
+	} else {
+		action = splits[1]
+	}
+
+	if action == "" {
+		return MidjourneyErrorWrapper(constant.MjRequestError, "unknown_action")
+	}
+	if strings.Contains(action, "upsample") {
+		index, err := strconv.Atoi(splits[3])
+		if err != nil {
+			return MidjourneyErrorWrapper(constant.MjRequestError, "index_parse_failed")
+		}
+		midjRequest.Index = index
+		midjRequest.Action = constant.MjActionUpscale
+	} else if strings.Contains(action, "variation") {
+		midjRequest.Index = 1
+		if action == "variation" {
+			index, err := strconv.Atoi(splits[3])
+			if err != nil {
+				return MidjourneyErrorWrapper(constant.MjRequestError, "index_parse_failed")
+			}
+			midjRequest.Index = index
+			midjRequest.Action = constant.MjActionVariation
+		} else if action == "low_variation" {
+			midjRequest.Action = constant.MjActionLowVariation
+		} else if action == "high_variation" {
+			midjRequest.Action = constant.MjActionHighVariation
+		}
+	} else if strings.Contains(action, "pan") {
+		midjRequest.Action = constant.MjActionPan
+		midjRequest.Index = 1
+	} else if strings.Contains(action, "reroll") {
+		midjRequest.Action = constant.MjActionReRoll
+		midjRequest.Index = 1
+	} else if action == "Outpaint" {
+		midjRequest.Action = constant.MjActionZoom
+		midjRequest.Index = 1
+	} else if action == "CustomZoom" {
+		midjRequest.Action = constant.MjActionCustomZoom
+		midjRequest.Index = 1
+	} else if action == "Inpaint" {
+		midjRequest.Action = constant.MjActionInPaint
+		midjRequest.Index = 1
+	} else {
+		return MidjourneyErrorWrapper(constant.MjRequestError, "unknown_action:"+customId)
+	}
+	return nil
+}
+
+func ConvertSimpleChangeParams(content string) *dto.MidjourneyRequest {
+	split := strings.Split(content, " ")
+	if len(split) != 2 {
+		return nil
+	}
+
+	action := strings.ToLower(split[1])
+	changeParams := &dto.MidjourneyRequest{}
+	changeParams.TaskId = split[0]
+
+	if action[0] == 'u' {
+		changeParams.Action = "UPSCALE"
+	} else if action[0] == 'v' {
+		changeParams.Action = "VARIATION"
+	} else if action == "r" {
+		changeParams.Action = "REROLL"
+		return changeParams
+	} else {
+		return nil
+	}
+
+	index, err := strconv.Atoi(action[1:2])
+	if err != nil || index < 1 || index > 4 {
+		return nil
+	}
+	changeParams.Index = index
+	return changeParams
+}
+
+func DoMidjourneyHttpRequest(c *gin.Context, timeout time.Duration, fullRequestURL string) (*dto.MidjourneyResponseWithStatusCode, []byte, error) {
+	var nullBytes []byte
+	//var requestBody io.Reader
+	//requestBody = c.Request.Body
+	// read request body to json, delete accountFilter and notifyHook
+	var mapResult map[string]interface{}
+	// if get request, no need to read request body
+	if c.Request.Method != "GET" {
+		err := json.NewDecoder(c.Request.Body).Decode(&mapResult)
+		if err != nil {
+			return MidjourneyErrorWithStatusCodeWrapper(constant.MjErrorUnknown, "read_request_body_failed", http.StatusInternalServerError), nullBytes, err
+		}
+		delete(mapResult, "accountFilter")
+		if !constant.MjNotifyEnabled {
+			delete(mapResult, "notifyHook")
+		}
+		//req, err := http.NewRequest(c.Request.Method, fullRequestURL, requestBody)
+		// make new request with mapResult
+	}
+	if constant.MjModeClearEnabled {
+		if prompt, ok := mapResult["prompt"].(string); ok {
+		    prompt = strings.Replace(prompt, "--fast", "", -1)
+		    prompt = strings.Replace(prompt, "--relax", "", -1)
+		    prompt = strings.Replace(prompt, "--turbo", "", -1)
+		    
+		    mapResult["prompt"] = prompt
+		}
+	}
+	reqBody, err := json.Marshal(mapResult)
+	if err != nil {
+		return MidjourneyErrorWithStatusCodeWrapper(constant.MjErrorUnknown, "marshal_request_body_failed", http.StatusInternalServerError), nullBytes, err
+	}
+	req, err := http.NewRequest(c.Request.Method, fullRequestURL, strings.NewReader(string(reqBody)))
+	if err != nil {
+		return MidjourneyErrorWithStatusCodeWrapper(constant.MjErrorUnknown, "create_request_failed", http.StatusInternalServerError), nullBytes, err
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	// 使用带有超时的 context 创建新的请求
+	req = req.WithContext(ctx)
+	req.Header.Set("Content-Type", c.Request.Header.Get("Content-Type"))
+	req.Header.Set("Accept", c.Request.Header.Get("Accept"))
+	auth := c.Request.Header.Get("Authorization")
+	if auth != "" {
+		auth = strings.TrimPrefix(auth, "Bearer ")
+		req.Header.Set("mj-api-secret", auth)
+	}
+	defer cancel()
+	resp, err := GetHttpClient().Do(req)
+	if err != nil {
+		common.SysError("do request failed: " + err.Error())
+		return MidjourneyErrorWithStatusCodeWrapper(constant.MjErrorUnknown, "do_request_failed", http.StatusInternalServerError), nullBytes, err
+	}
+	statusCode := resp.StatusCode
+	//if statusCode != 200  {
+	//	return MidjourneyErrorWithStatusCodeWrapper(constant.MjErrorUnknown, "bad_response_status_code", statusCode), nullBytes, nil
+	//}
+	err = req.Body.Close()
+	if err != nil {
+		return MidjourneyErrorWithStatusCodeWrapper(constant.MjErrorUnknown, "close_request_body_failed", statusCode), nullBytes, err
+	}
+	err = c.Request.Body.Close()
+	if err != nil {
+		return MidjourneyErrorWithStatusCodeWrapper(constant.MjErrorUnknown, "close_request_body_failed", statusCode), nullBytes, err
+	}
+	var midjResponse dto.MidjourneyResponse
+
+	responseBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return MidjourneyErrorWithStatusCodeWrapper(constant.MjErrorUnknown, "read_response_body_failed", statusCode), nullBytes, err
+	}
+	err = resp.Body.Close()
+	if err != nil {
+		return MidjourneyErrorWithStatusCodeWrapper(constant.MjErrorUnknown, "close_response_body_failed", statusCode), responseBody, err
+	}
+	respStr := string(responseBody)
+	log.Printf("responseBody: %s", respStr)
+	if respStr == "" {
+		return MidjourneyErrorWithStatusCodeWrapper(constant.MjErrorUnknown, "empty_response_body", statusCode), responseBody, nil
+	} else {
+		err = json.Unmarshal(responseBody, &midjResponse)
+		if err != nil {
+			return MidjourneyErrorWithStatusCodeWrapper(constant.MjErrorUnknown, "unmarshal_response_body_failed", statusCode), responseBody, err
+		}
+	}
+	//log.Printf("midjResponse: %v", midjResponse)
+	//for k, v := range resp.Header {
+	//	c.Writer.Header().Set(k, v[0])
+	//}
+	return &dto.MidjourneyResponseWithStatusCode{
+		StatusCode: statusCode,
+		Response:   midjResponse,
+	}, responseBody, nil
+}
--- a/service/sensitive.go
+++ b/service/sensitive.go
@@ -0,0 +1,71 @@
+package service
+
+import (
+	"bytes"
+	"fmt"
+	"github.com/anknown/ahocorasick"
+	"one-api/constant"
+	"strings"
+)
+
+// SensitiveWordContains 是否包含敏感词，返回是否包含敏感词和敏感词列表
+func SensitiveWordContains(text string) (bool, []string) {
+	if len(constant.SensitiveWords) == 0 {
+		return false, nil
+	}
+	checkText := strings.ToLower(text)
+	// 构建一个AC自动机
+	m := initAc()
+	hits := m.MultiPatternSearch([]rune(checkText), false)
+	if len(hits) > 0 {
+		words := make([]string, 0)
+		for _, hit := range hits {
+			words = append(words, string(hit.Word))
+		}
+		return true, words
+	}
+	return false, nil
+}
+
+// SensitiveWordReplace 敏感词替换，返回是否包含敏感词和替换后的文本
+func SensitiveWordReplace(text string, returnImmediately bool) (bool, []string, string) {
+	if len(constant.SensitiveWords) == 0 {
+		return false, nil, text
+	}
+	checkText := strings.ToLower(text)
+	m := initAc()
+	hits := m.MultiPatternSearch([]rune(checkText), returnImmediately)
+	if len(hits) > 0 {
+		words := make([]string, 0)
+		for _, hit := range hits {
+			pos := hit.Pos
+			word := string(hit.Word)
+			text = text[:pos] + "**###**" + text[pos+len(word):]
+			words = append(words, word)
+		}
+		return true, words, text
+	}
+	return false, nil, text
+}
+
+func initAc() *goahocorasick.Machine {
+	m := new(goahocorasick.Machine)
+	dict := readRunes()
+	if err := m.Build(dict); err != nil {
+		fmt.Println(err)
+		return nil
+	}
+	return m
+}
+
+func readRunes() [][]rune {
+	var dict [][]rune
+
+	for _, word := range constant.SensitiveWords {
+		word = strings.ToLower(word)
+		l := bytes.TrimSpace([]byte(word))
+		dict = append(dict, bytes.Runes(l))
+	}
+
+	return dict
+}
--- a/service/token_counter.go
+++ b/service/token_counter.go
@@ -29,7 +29,7 @@ func InitTokenEncoders() {
 	if err != nil {
 		common.FatalLog(fmt.Sprintf("failed to get gpt-4 token encoder: %s", err.Error()))
 	}
-	for model, _ := range common.ModelRatio {
+	for model, _ := range common.DefaultModelRatio {
 		if strings.HasPrefix(model, "gpt-3.5") {
 			tokenEncoderMap[model] = gpt35TokenEncoder
 		} else if strings.HasPrefix(model, "gpt-4") {
@@ -116,7 +116,7 @@ func getImageToken(imageUrl *dto.MessageImageUrl) (int, error) {
 	return tiles*170 + 85, nil
 }

-func CountTokenMessages(messages []dto.Message, model string) (int, error) {
+func CountTokenMessages(messages []dto.Message, model string, checkSensitive bool) (int, error, bool) {
 	//recover when panic
 	tokenEncoder := getTokenEncoder(model)
 	// Reference:
@@ -142,8 +142,15 @@ func CountTokenMessages(messages []dto.Message, model string) (int, error) {
 			if err := json.Unmarshal(message.Content, &arrayContent); err != nil {
 				var stringContent string
 				if err := json.Unmarshal(message.Content, &stringContent); err != nil {
-					return 0, err
+					return 0, err, false
 				} else {
+					if checkSensitive {
+						contains, words := SensitiveWordContains(stringContent)
+						if contains {
+							err := fmt.Errorf("message contains sensitive words: [%s]", strings.Join(words, ", "))
+							return 0, err, true
+						}
+					}
 					tokenNum += getTokenNum(tokenEncoder, stringContent)
 					if message.Name != nil {
 						tokenNum += tokensPerName
@@ -174,7 +181,7 @@ func CountTokenMessages(messages []dto.Message, model string) (int, error) {
 								imageTokenNum, err = getImageToken(&imageUrl)
 							}
 							if err != nil {
-								return 0, err
+								return 0, err, false
 							}
 						}
 						tokenNum += imageTokenNum
@@ -187,32 +194,63 @@ func CountTokenMessages(messages []dto.Message, model string) (int, error) {
 		}
 	}
 	tokenNum += 3 // Every reply is primed with <|start|>assistant<|message|>
-	return tokenNum, nil
+	return tokenNum, nil, false
 }

-func CountTokenInput(input any, model string) int {
+func CountTokenInput(input any, model string, check bool) (int, error, bool) {
 	switch v := input.(type) {
 	case string:
-		return CountTokenText(v, model)
+		return CountTokenText(v, model, check)
 	case []string:
 		text := ""
 		for _, s := range v {
 			text += s
 		}
-		return CountTokenText(text, model)
+		return CountTokenText(text, model, check)
 	}
-	return 0
+	return CountTokenInput(fmt.Sprintf("%v", input), model, check)
 }

-func CountAudioToken(text string, model string) int {
+func CountTokenStreamChoices(messages []dto.ChatCompletionsStreamResponseChoice, model string) int {
+	tokens := 0
+	for _, message := range messages {
+		tkm, _, _ := CountTokenInput(message.Delta.Content, model, false)
+		tokens += tkm
+		if message.Delta.ToolCalls != nil {
+			for _, tool := range message.Delta.ToolCalls {
+				tkm, _, _ := CountTokenInput(tool.Function.Name, model, false)
+				tokens += tkm
+				tkm, _, _ = CountTokenInput(tool.Function.Arguments, model, false)
+				tokens += tkm
+			}
+		}
+	}
+	return tokens
+}
+
+func CountAudioToken(text string, model string, check bool) (int, error, bool) {
 	if strings.HasPrefix(model, "tts") {
-		return utf8.RuneCountInString(text)
+		contains, words := SensitiveWordContains(text)
+		if contains {
+			return utf8.RuneCountInString(text), fmt.Errorf("input contains sensitive words: [%s]", strings.Join(words, ",")), true
+		}
+		return utf8.RuneCountInString(text), nil, false
 	} else {
-		return CountTokenText(text, model)
+		return CountTokenText(text, model, check)
 	}
 }

-func CountTokenText(text string, model string) int {
+// CountTokenText 统计文本的token数量，仅当文本包含敏感词，返回错误，同时返回token数量
+func CountTokenText(text string, model string, check bool) (int, error, bool) {
+	var err error
+	var trigger bool
+	if check {
+		contains, words := SensitiveWordContains(text)
+		if contains {
+			err = fmt.Errorf("input contains sensitive words: [%s]", strings.Join(words, ","))
+			trigger = true
+		}
+	}
 	tokenEncoder := getTokenEncoder(model)
-	return getTokenNum(tokenEncoder, text)
+	return getTokenNum(tokenEncoder, text), err, trigger
 }
--- a/service/usage_helpr.go
+++ b/service/usage_helpr.go
@@ -1,27 +1,26 @@
 package service

 import (
-	"errors"
 	"one-api/dto"
-	"one-api/relay/constant"
 )

-func GetPromptTokens(textRequest dto.GeneralOpenAIRequest, relayMode int) (int, error) {
-	switch relayMode {
-	case constant.RelayModeChatCompletions:
-		return CountTokenMessages(textRequest.Messages, textRequest.Model)
-	case constant.RelayModeCompletions:
-		return CountTokenInput(textRequest.Prompt, textRequest.Model), nil
-	case constant.RelayModeModerations:
-		return CountTokenInput(textRequest.Input, textRequest.Model), nil
-	}
-	return 0, errors.New("unknown relay mode")
-}
+//func GetPromptTokens(textRequest dto.GeneralOpenAIRequest, relayMode int) (int, error) {
+//	switch relayMode {
+//	case constant.RelayModeChatCompletions:
+//		return CountTokenMessages(textRequest.Messages, textRequest.Model)
+//	case constant.RelayModeCompletions:
+//		return CountTokenInput(textRequest.Prompt, textRequest.Model), nil
+//	case constant.RelayModeModerations:
+//		return CountTokenInput(textRequest.Input, textRequest.Model), nil
+//	}
+//	return 0, errors.New("unknown relay mode")
+//}

-func ResponseText2Usage(responseText string, modeName string, promptTokens int) *dto.Usage {
+func ResponseText2Usage(responseText string, modeName string, promptTokens int) (*dto.Usage, error) {
 	usage := &dto.Usage{}
 	usage.PromptTokens = promptTokens
-	usage.CompletionTokens = CountTokenText(responseText, modeName)
+	ctkm, err, _ := CountTokenText(responseText, modeName, false)
+	usage.CompletionTokens = ctkm
 	usage.TotalTokens = usage.PromptTokens + usage.CompletionTokens
-	return usage
+	return usage, err
 }
--- a/web/.prettierrc.mjs
+++ b/web/.prettierrc.mjs
@@ -0,0 +1 @@
+module.exports = require("@so1ve/prettier-config");
--- a/web/README.md
+++ b/web/README.md
@@ -18,4 +18,4 @@ Before you start editing, make sure your `Actions on Save` options have `Optimiz
 ## Reference

 1. https://github.com/OIerDb-ng/OIerDb
-2. https://github.com/cornflourblue/react-hooks-redux-registration-login-example
+2. https://github.com/cornflourblue/react-hooks-redux-registration-login-example
--- a/web/index.html
+++ b/web/index.html
@@ -0,0 +1,19 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <link rel="icon" href="/logo.png" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="theme-color" content="#ffffff" />
+    <meta
+      name="description"
+      content="OpenAI 接口聚合管理，支持多种渠道包括 Azure，可用于二次分发管理 key，仅单可执行文件，已打包好 Docker 镜像，一键部署，开箱即用"
+    />
+    <title>New API</title>
+  </head>
+  <body>
+    <noscript>You need to enable JavaScript to run this app.</noscript>
+    <div id="root"></div>
+    <script type="module" src="/src/index.js"></script>
+  </body>
+</html>
--- a/web/package.json
+++ b/web/package.json
@@ -2,6 +2,7 @@
  "name": "react-template",
  "version": "0.1.0",
  "private": true,
+  "type": "module",
  "dependencies": {
    "@douyinfe/semi-icons": "^2.46.1",
    "@douyinfe/semi-ui": "^2.46.1",
@@ -16,19 +17,18 @@
    "react-dropzone": "^14.2.3",
    "react-fireworks": "^1.0.4",
    "react-router-dom": "^6.3.0",
-    "react-scripts": "5.0.1",
    "react-telegram-login": "^1.1.2",
    "react-toastify": "^9.0.8",
    "react-turnstile": "^1.0.5",
-    "semantic-ui-css": "^2.5.0",
-    "semantic-ui-react": "^2.1.3",
-    "usehooks-ts": "^2.9.1"
+    "semantic-ui-offline": "^2.5.0",
+    "semantic-ui-react": "^2.1.3"
  },
  "scripts": {
-    "start": "react-scripts start",
-    "build": "react-scripts build",
-    "test": "react-scripts test",
-    "eject": "react-scripts eject"
+    "dev": "vite",
+    "build": "vite build",
+    "lint": "prettier . --check",
+    "lint:fix": "prettier . --write",
+    "preview": "vite preview"
  },
  "eslintConfig": {
    "extends": [
@@ -49,8 +49,11 @@
    ]
  },
  "devDependencies": {
-    "prettier": "^2.7.1",
-    "typescript": "4.4.2"
+    "@so1ve/prettier-config": "^2.0.0",
+    "@vitejs/plugin-react": "^4.2.1",
+    "prettier": "^3.0.0",
+    "typescript": "4.4.2",
+    "vite": "^5.2.0"
  },
  "prettier": {
    "singleQuote": true,
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
CaIon	9294127686	feat: support aws claude	2024-04-23 11:44:40 +08:00
CaIon	6b97842f78	feat: 支持ollama embedding数组传参	2024-04-22 21:09:11 +08:00
CaIon	bdc65bdba2	feat: 启用函数计费	2024-04-22 16:35:56 +08:00
CaIon	76dc7af8d1	feat: update gemini model	2024-04-21 12:51:08 +08:00
CaIon	892b7d1ad4	feat: 登陆美化	2024-04-20 21:05:38 +08:00
CaIon	6b71db7ce2	feat: 状态码复写	2024-04-20 21:05:23 +08:00
CaIon	b8fb351fd8	feat: 在重试时打印重试信息	2024-04-20 17:18:14 +08:00
CaIon	e6765ef32d	feat: update cache	2024-04-18 20:30:17 +08:00
CaIon	4ef98ba7eb	feat: update cache	2024-04-18 20:26:38 +08:00
CaIon	65b85377c6	feat: update cache #204	2024-04-18 20:23:44 +08:00
CaIon	c6e85d5b57	feat: 完善数据看板 #190	2024-04-18 19:37:52 +08:00
CaIon	1162683b4d	feat: 可设置是否转发上游mj图片地址	2024-04-18 18:02:09 +08:00
CaIon	818bd824da	feat: 前端不显示敏感信息	2024-04-18 17:52:18 +08:00
CaIon	6e54f01435	update makefile	2024-04-17 20:47:35 +08:00
CaIon	505916b755	update makefile	2024-04-17 20:47:13 +08:00
CaIon	a4defe6ada	fix: test all channel error (close #206 )	2024-04-17 15:18:36 +08:00
Calcium-Ion	9dfd405ba9	Merge pull request #208 from kahosan/refactor_dark_mode fix: the dark mode does not work for the `OperationSetting` and `SystemSetting` panels	2024-04-17 15:13:24 +08:00
Calcium-Ion	6c5b94ceb0	Merge pull request #194 from iszcz/pr feat: 新增渠道复制功能	2024-04-17 15:12:15 +08:00
Calcium-Ion	ac2984315a	Merge pull request #205 from MapleEve/main fix: Gemini new model name error and Support both v1 and v1beta models	2024-04-17 15:10:49 +08:00
kahosan	848358d876	fix: the dark mode does not work for the `OperationSetting` and `SystemSetting` panels	2024-04-16 17:12:54 +08:00
kahosan	e9abe5b705	refactor: dark mode	2024-04-16 17:11:39 +08:00
Maple Gao	d7e117acf5	fix: Gemini 1.5 name error	2024-04-15 14:27:18 +08:00
Maple Gao	1456992aae	add: new Gemini model default ratio	2024-04-15 14:25:44 +08:00
Maple Gao	3b6ea51033	fix: rename the latest Gemini model name	2024-04-15 14:22:40 +08:00
Maple Gao	21250a46a6	feat: support google v1beta and Gemini Ultra	2024-04-15 14:19:19 +08:00
iszcz	b31fadd74f	Merge branch 'Calcium-Ion:main' into pr	2024-04-11 18:15:54 +08:00
Calcium-Ion	300947f400	Merge pull request #197 from xqx333/main Update model-ratio.go	2024-04-11 14:15:33 +08:00
xqx333	bf94893f6a	Update model-ratio.go 修复gpt-4-1106-preview和gpt-4-0125-preview的输出倍率错误	2024-04-11 14:03:51 +08:00
iszcz	97af77b26c	Merge branch 'Calcium-Ion:main' into pr	2024-04-11 05:40:52 +08:00
1808837298@qq.com	4ef2422b97	update model-ratio	2024-04-10 20:12:56 +08:00
1808837298@qq.com	f188147680	feat: support gpt-4-turbo	2024-04-10 20:10:54 +08:00
iszcz	08e10df887	新增渠道复制	2024-04-10 03:17:16 +08:00
Calcium-Ion	0a49715c3d	Merge pull request #183 from iszcz/patch-1 清除mj prompt里的--mode	2024-04-09 00:46:47 +08:00
Calcium-Ion	89efed48fc	Merge pull request #185 from h1xy/main Fix: CompletionRatio is not working for openrouter.ai	2024-04-08 23:57:37 +08:00
Calcium-Ion	97e0aae0a7	Merge pull request #188 from Calcium-Ion/fix/many-model-error fix: 修复渠道一次性添加很多model失败	2024-04-08 23:56:45 +08:00
Xyfacai	320da09f36	fix: 修复渠道一次性添加很多model失败修复渠道一次性添加很多model并且group多提示失败 too many SQL variables	2024-04-08 23:51:51 +08:00
CaIon	2d849e0dd6	fix: 307本地重试	2024-04-08 14:10:09 +08:00
CaIon	60d7ed3fb5	fix: distributor panic	2024-04-08 13:48:36 +08:00
h1xy	c5f6d0e063	Fix: CompletionRatio is not working for openrouter.ai https://openrouter.ai/docs#models Model name of openrouter is prefix with company name, e.g. "model": "anthropic/claude-3-opus:beta", therefore, CompletionRatio will not working for it which is only work for prefix with claude-xxx	2024-04-08 02:12:47 +08:00
CaIon	a7cfce24d0	feat: automatically ban channels that exceeded quota	2024-04-07 22:22:27 +08:00
CaIon	34bf8f8945	fix: select channel	2024-04-07 22:08:11 +08:00
CaIon	2d1d1b4631	update go-epay	2024-04-07 14:42:03 +08:00
iszcz	5961de03e7	清除--mode	2024-04-06 23:08:50 +08:00
CaIon	fbdb17022c	update README.md	2024-04-06 20:49:34 +08:00
CaIon	497cc32634	update README.md	2024-04-06 20:47:16 +08:00
CaIon	462c328d4b	feat: 支持未开启缓存下本地重试	2024-04-06 20:45:18 +08:00
CaIon	257cfc2390	fix: email whitelist check	2024-04-06 17:50:47 +08:00
CaIon	fed1a1d6a3	feat: 超时状态码不重试	2024-04-04 21:21:44 +08:00
CaIon	fc9f8c8e8a	fix: add group tag 'unknown'	2024-04-04 21:20:54 +08:00
CaIon	f3f36dafbd	chore: 优化按次计费的数据库查询次数	2024-04-04 20:10:30 +08:00
CaIon	aaf3a1f07b	fix: GetRandomSatisfiedChannel	2024-04-04 19:37:33 +08:00
CaIon	c040fa229d	fix bug	2024-04-04 19:18:00 +08:00
CaIon	1cd1e54be4	feat: 钱包兼容非货币形式显示额度	2024-04-04 18:21:23 +08:00
CaIon	3db64afc7f	feat: 钱包兼容非货币形式显示额度	2024-04-04 18:20:38 +08:00
CaIon	bc9cfa5da0	feat: 钱包兼容非货币形式显示额度	2024-04-04 18:18:18 +08:00
CaIon	660b9b3c99	feat: able to set default test model (#138 )	2024-04-04 17:29:25 +08:00
CaIon	cdf2087952	update README.md	2024-04-04 16:48:28 +08:00
CaIon	4b60528c5f	feat: 本地重试	2024-04-04 16:35:44 +08:00
1808837298@qq.com	9025756b56	fix: email whitelist check	2024-04-04 12:33:11 +08:00
CaIon	2ea6009954	fix: user update error	2024-04-04 11:10:41 +08:00
CaIon	a33f685f3c	fix: log page type error (close #154 )	2024-04-03 23:57:49 +08:00
CaIon	3d0f77ffb6	Merge remote-tracking branch 'origin/main'	2024-04-03 23:51:32 +08:00
CaIon	5ce8e6dab6	fix: update user quote (close #161 )	2024-04-03 23:51:25 +08:00
Calcium-Ion	5a5b7d618d	Merge pull request #171 from QuentinHsu/perf-setting-tab-navigation perf(Setting): setting tab navigation	2024-04-03 23:32:19 +08:00
Calcium-Ion	ad8ce915ec	Merge pull request #175 from ye4293/test 修改了用户注册使用临时邮箱验证的问题	2024-04-03 23:31:50 +08:00
Calcium-Ion	456fb875de	Merge pull request #176 from QuentinHsu/perf-helpers-renderGroup refactor(helpers): renderGroup function	2024-04-03 23:31:02 +08:00
QuentinHsu	3e90b6d516	refactor(helpers): renderGroup function	2024-04-02 13:16:02 +08:00
QuentinHsu	d6e373fbe4	fix(helpers): add key prop to Tag components	2024-04-02 10:58:44 +08:00
Ghostz	224746b45a	Update misc.go	2024-04-02 01:13:12 +08:00
Calcium-Ion	ac827b1862	Merge pull request #174 from AI-ASS/main	2024-04-01 19:51:02 +08:00
GAI Group	658bf2ad57	Rename .prettierrc.mjs to .prettierrc.mjs	2024-04-01 19:49:56 +08:00
Calcium-Ion	c25f48b7c5	Merge pull request #172 from MapleEve/main Support Claude TopK	2024-04-01 18:15:45 +08:00
QuentinHsu	290dcf7587	perf(Setting): add useEffect and useNavigate hooks to Setting component	2024-04-01 16:59:07 +08:00
Maple Gao	278fd39195	feat: add Claude TopK	2024-04-01 14:33:58 +08:00
QuentinHsu	aa23c51a53	perf(Setting): add tabActiveKey state to Setting component	2024-04-01 13:33:57 +08:00
Calcium-Ion	87919b032d	Merge pull request #167 from weikecloud/main 增加MJ上游构图失败判断	2024-03-30 16:27:03 +08:00
Calcium-Ion	f7a4f18aff	Update midjourney.go	2024-03-30 16:26:39 +08:00
余生一个白恩	706449dede	增加上游构图失败判断	2024-03-30 13:21:05 +08:00
CaIon	36d164be0e	fix: SearchUsers (close #160 )	2024-03-29 22:49:08 +08:00
CaIon	d80a7d3c97	Merge remote-tracking branch 'origin/main'	2024-03-29 22:28:10 +08:00
CaIon	44a8ade4ba	fix: remove sensitive check on completion (close #157 )	2024-03-29 22:20:14 +08:00
Xyfacai	2cca2a989e	Merge pull request #165 from xyfacai/fork/mj-mode-path fix: 支持 /mj-{mode} 路径	2024-03-29 17:45:23 +08:00
Xiangyuan Liu	3065bf92ae	fix: 支持 /mj-{mode} 路径	2024-03-29 17:45:00 +08:00
Xiangyuan Liu	2e595bdafb	fix: 支持 /mj-{mode} 路径	2024-03-29 16:58:19 +08:00
Xiangyuan Liu	49df4b6eed	feat: 支持 /mj-{mode} 路径	2024-03-29 16:48:50 +08:00
CaIon	5c39f54040	feat: able to set smtp ssl	2024-03-28 12:18:11 +08:00
CaIon	786ccc7da0	feat: 开启redis的情况下设置SYNC_FREQUENCY默认为60	2024-03-26 23:00:04 +08:00
CaIon	8eedad9470	feat: support ollama embedding	2024-03-26 19:53:53 +08:00
CaIon	319e97d677	fix: ollama channel test	2024-03-26 19:27:11 +08:00
CaIon	6114c9bb96	fix: CountTokenInput	2024-03-26 18:49:53 +08:00
CaIon	3cf2f0d5cb	fix: CountTokenInput	2024-03-26 18:21:38 +08:00
CaIon	2a345ae070	ci: update ci	2024-03-25 22:55:33 +08:00
CaIon	d8c91fa448	feat: 进一步防止暴露数上游以及数据库地址	2024-03-25 22:54:15 +08:00
CaIon	cc8cc8b386	fix: try to fix 307	2024-03-25 22:51:31 +08:00
CaIon	1587ea565b	feat: support gemini-1.5	2024-03-25 22:33:46 +08:00
CaIon	a7a1fc615d	feat: remove azure model TrimPrefix	2024-03-25 22:33:33 +08:00
CaIon	b2a280c1ec	fix: 无法复制弹窗过小	2024-03-25 16:49:53 +08:00
CaIon	f1fb7b32a3	chore: update model ratio	2024-03-25 16:17:35 +08:00
CaIon	3800dc219e	fix: Cannot read properties of undefined (reading 'map') (close #148 )	2024-03-25 14:11:28 +08:00
CaIon	72962e988f	Merge remote-tracking branch 'origin/main'	2024-03-25 13:52:37 +08:00
Calcium-Ion	01e3acfada	Merge pull request #145 from QuentinHsu/fix-dev-error fix(global): error in console under dev mode	2024-03-25 13:52:22 +08:00
QuentinHsu	f671176da0	fix(global): error in console under dev mode	2024-03-24 18:50:21 +08:00
CaIon	2d36dee17c	fix: 流模式网络错误导致0补	2024-03-23 23:52:04 +08:00
CaIon	6eb30ec3e6	fix: 模型倍率和价格无法设置	2024-03-23 23:24:17 +08:00
CaIon	0b3520e3c8	fix: 修复默认模型倍率未显示	2024-03-23 23:21:14 +08:00
CaIon	63304a5b2d	Merge remote-tracking branch 'origin/main'	2024-03-23 21:49:13 +08:00
CaIon	66e30f4115	fix: ci	2024-03-23 21:47:51 +08:00
Calcium-Ion	0618f03c68	Merge pull request #141 from Calcium-Ion/vite-support feat: vite	2024-03-23 21:42:56 +08:00
CaIon	962dc984f4	chore: lint fix	2024-03-23 21:24:39 +08:00
CaIon	15e7307320	feat: prettier	2024-03-23 21:23:39 +08:00
CaIon	951383c371	chore: delete useless file	2024-03-23 21:02:38 +08:00
CaIon	87b6210045	chore: delete useless dir	2024-03-23 21:00:23 +08:00
CaIon	525fc1b3b7	feat: 从本地读取字体 (close #130 )	2024-03-23 20:57:52 +08:00
CaIon	58f2cf3a79	feat: 首页加载速度优化	2024-03-23 20:22:00 +08:00
CaIon	06c86397e1	chore: Chunking Strategy	2024-03-23 19:37:19 +08:00
CaIon	21f48b55e0	fix: embed	2024-03-23 19:27:18 +08:00
CaIon	f823b4d4d8	update Dockerfile	2024-03-23 19:18:28 +08:00
CaIon	93be61aaf3	feat: vite	2024-03-23 19:09:09 +08:00
Calcium-Ion	a500097b36	Merge pull request #137 from MapleEve/main feat: support 01.AI	2024-03-23 17:38:53 +08:00
CaIon	67332bc8df	fix: 模型固定价格为空时错误使用默认价格	2024-03-23 17:19:29 +08:00
CaIon	d0acecb2ab	fix: GLM-4V 的 Vision 兼容问题 (close #136 )	2024-03-23 17:08:34 +08:00
Maple Gao	a825699e9a	Merge branch 'Calcium-Ion:main' into main	2024-03-23 01:10:39 +08:00
CaIon	a70ca53449	fix: mj	2024-03-22 21:39:44 +08:00
CaIon	c33b1522cc	fix: 充值并发导致订单号相同	2024-03-21 23:57:48 +08:00
CaIon	ff7da08bad	fix: add missing created	2024-03-21 23:46:43 +08:00
CaIon	3e03c5a742	fix: add missing id,object,created	2024-03-21 23:44:39 +08:00
CaIon	d9344d79cf	fix: try to fix curl: (18)	2024-03-21 23:25:07 +08:00
CaIon	c4b3d3a975	fix: fix embedding	2024-03-21 17:39:05 +08:00
CaIon	031957714a	refactor: 代码结构优化	2024-03-21 17:19:21 +08:00
CaIon	3f808be254	fix: add missing version	2024-03-21 16:26:26 +08:00
CaIon	9b64f4a34a	fix: fix mj panic	2024-03-21 15:04:04 +08:00
CaIon	222a55387d	fix: fix SensitiveWords error	2024-03-21 14:29:56 +08:00
Maple Gao	492001a8b2	Merge branch 'Calcium-Ion:main' into main	2024-03-21 01:40:29 +08:00
CaIon	d7e25e1604	fix: fix SensitiveWords load error	2024-03-20 23:58:42 +08:00
Maple Gao	7d64f30f4d	Add: 01AI in readme	2024-03-20 23:51:45 +08:00
Maple Gao	9e157ed802	fix empty url	2024-03-20 23:49:16 +08:00
Maple Gao	cfabf8a656	Add 01.AI relay	2024-03-20 23:44:03 +08:00
CaIon	c7658b70d1	fix: 敏感词库为空时，不检测	2024-03-20 22:33:22 +08:00
CaIon	d5e93e788d	fix: midjourneys table	2024-03-20 21:49:54 +08:00
CaIon	dd71946047	fix: claude panic	2024-03-20 21:32:33 +08:00
CaIon	b736de7189	fix: claude panic	2024-03-20 21:28:45 +08:00
Calcium-Ion	5e7774cf08	Merge pull request #131 from Calcium-Ion/sensitive-words feat: 敏感词过滤	2024-03-20 20:38:15 +08:00
CaIon	a232afe9fd	feat: 统一错误提示	2024-03-20 20:36:55 +08:00
CaIon	eb6257a8d8	fix: fix SensitiveWordContains not working	2024-03-20 20:28:00 +08:00
CaIon	47b9f48544	fix: fix error	2024-03-20 20:26:34 +08:00
CaIon	2db4282666	feat: 保留功能	2024-03-20 20:15:32 +08:00
CaIon	64b9d3b58c	feat: 初步兼容生成内容检查	2024-03-20 19:00:51 +08:00
CaIon	7a663d26ec	feat: 初步兼容敏感词过滤	2024-03-20 17:07:42 +08:00
CaIon	bec21ade9d	Update README.md	2024-03-18 20:44:20 +08:00
CaIon	4c4e087060	fix: api type error	2024-03-18 19:55:19 +08:00
CaIon	beadb98a8c	feat: support perplexity	2024-03-18 18:09:41 +08:00
CaIon	615d109d70	Merge remote-tracking branch 'origin/main'	2024-03-18 18:08:09 +08:00
Calcium-Ion	0da49fa446	Merge pull request #125 from wozulong/main fix: openai_organization not working	2024-03-18 18:07:34 +08:00
CaIon	578b5f6536	feat: support perplexity	2024-03-18 18:00:19 +08:00
我秦始皇	f63ad9c03c	fix: make the 'openai_organization' parameter actually work.	2024-03-18 02:19:59 -07:00
我秦始皇	0fb98e44a7	fix: make the 'openai_organization' parameter actually work.	2024-03-18 02:11:21 -07:00
CaIon	652bb4a53c	Update README.md	2024-03-18 00:16:32 +08:00
CaIon	a26b9a9bff	Update Midjourney.md	2024-03-18 00:13:37 +08:00
CaIon	f82aa956bd	feat: midjourneys表添加索引	2024-03-17 22:56:17 +08:00
CaIon	b8c053c37f	fix: chatglm top_p error (close #124 )	2024-03-17 22:55:29 +08:00
CaIon	2581b37394	fix: 侧边栏聚焦问题 (close #123 )	2024-03-17 16:37:19 +08:00
CaIon	f65477d054	fix: 修复日志翻页问题 (close #122 )	2024-03-17 16:18:45 +08:00
CaIon	4b952b8582	feat: print midjourney-proxy request error	2024-03-16 17:25:10 +08:00
CaIon	a6ba1d01d9	feat: 添加回调未开启提示	2024-03-15 22:15:16 +08:00
CaIon	2d2fec24d0	chore: update dependency	2024-03-15 18:35:15 +08:00
CaIon	d34b55c154	chore: reformat code	2024-03-15 16:05:33 +08:00
CaIon	25ec99913b	feat: Add logs page-size	2024-03-15 15:07:14 +08:00
CaIon	7f22d58574	feat: Only update weight and priority when blur	2024-03-15 14:53:33 +08:00
CaIon	dfdeadf1a5	feat: Remember and automatically set page-size (close #118 )	2024-03-15 14:45:52 +08:00
CaIon	6ab1b3a524	fix: fix image-seed error	2024-03-14 22:17:03 +08:00
CaIon	4917e5a92f	feat: 允许开关mj回调	2024-03-14 21:21:37 +08:00
Calcium-Ion	f62dcbf669	Merge pull request #114 from Calcium-Ion/midjourney-proxy-plus feat: support midjourney-proxy-plus	2024-03-14 18:49:30 +08:00
CaIon	299911d4cd	fix: 修复epay可能重复回调的问题	2024-03-14 18:33:35 +08:00
CaIon	84e0544604	refactor: 修改超时时间	2024-03-14 18:19:22 +08:00
CaIon	2786a6b539	Update README.md	2024-03-14 18:10:09 +08:00
CaIon	9b5353a81a	feat: support InsightFace (close #60 )	2024-03-14 18:09:57 +08:00
CaIon	bc5a54df59	feat: support image-seed (close #86 )	2024-03-14 18:09:56 +08:00
CaIon	d704902b70	feat: 兼容自定义变焦，完善modal操作	2024-03-14 16:42:37 +08:00
CaIon	614220a0fb	feat: 超过一小时的任务自动失败	2024-03-14 15:16:36 +08:00
CaIon	98c1f66d61	feat: support Anthropic Claude 3.0 Haiku (close #116 )	2024-03-14 14:28:21 +08:00
CaIon	a77fbc0fa2	fix: reroll action error	2024-03-14 00:43:32 +08:00
CaIon	44361d75e8	fix: "Inpaint" code error	2024-03-13 23:17:12 +08:00
CaIon	9b2e5c2978	refactor: remove consumeQuota	2024-03-13 22:30:10 +08:00
CaIon	d3399d68f6	fix: fix typo	2024-03-13 22:24:02 +08:00
CaIon	3d10c9f090	feat: 将操作拆分成单独的模型	2024-03-13 21:19:48 +08:00
CaIon	d5ffaf2502	feat: 操作细分	2024-03-13 18:26:16 +08:00
CaIon	2ad591411e	feat: support shorten	2024-03-13 17:46:34 +08:00
CaIon	728dbed28d	feat: 兼容变焦功能	2024-03-13 16:29:27 +08:00
CaIon	fd3a41bacb	feat: 请求超时处理	2024-03-13 16:19:22 +08:00
CaIon	37c0c8ebdd	feat: 初步兼容midjourney-proxy-plus	2024-03-13 15:37:01 +08:00
CaIon	95d8059c90	Merge remote-tracking branch 'origin/main'	2024-03-12 18:18:57 +08:00
CaIon	c012306400	feat: add parameter top_k	2024-03-12 18:18:47 +08:00
Calcium-Ion	1e1a53e4d2	Merge pull request #113 from xyspg/main fix: layout issues	2024-03-12 17:36:02 +08:00
Kang Jiaming	30d48ea473	fix: layout issues	2024-03-12 12:49:36 +08:00
CaIon	9e5c636490	Update README.md	2024-03-12 02:39:10 +08:00
CaIon	d53d3386e9	feat: support ollama (close #112 )	2024-03-12 02:36:39 +08:00
CaIon	c3a01decd8	chore: drop idx_channels_key on start	2024-03-12 00:35:12 +08:00
CaIon	c29680b301	feat: 前端美化	2024-03-11 21:08:51 +08:00
CaIon	ac7407ce9c	Update README.md	2024-03-11 19:27:54 +08:00
Calcium-Ion	3ea061a820	Merge pull request #98 from h1xy/main Update README.md	2024-03-11 19:23:42 +08:00
CaIon	d4df1960b2	fix: 修复模型映射功能失效 (close #105 )	2024-03-11 18:28:51 +08:00
CaIon	97dd80541b	fix: 请求阿里通义千问异常 (close #108 )	2024-03-11 14:35:46 +08:00
CaIon	bf241b218f	fix: 删除用户改为软删除 (close #107 )	2024-03-11 14:13:45 +08:00
CaIon	7ab6c6c303	fix: 修复claude渠道流模式计费可能异常	2024-03-09 13:25:47 +08:00
h1xy	9e0a54e943	Update README.md 增加telegram授权登录的配置步骤。	2024-03-06 23:37:32 +08:00
				`@@ -0,0 +1 @@`
				`module.exports = require("@so1ve/prettier-config");`