添加完整项目文件

包含Go API项目的所有源代码、配置文件、Docker配置、文档和前端资源 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
2025-08-21 23:33:10 +08:00
parent 69af9723d9
commit fb44c8bf03
513 changed files with 90387 additions and 0 deletions
--- a/setting/auto_group.go
+++ b/setting/auto_group.go
@@ -0,0 +1,31 @@
+package setting
+
+import "encoding/json"
+
+var AutoGroups = []string{
+	"default",
+}
+
+var DefaultUseAutoGroup = false
+
+func ContainsAutoGroup(group string) bool {
+	for _, autoGroup := range AutoGroups {
+		if autoGroup == group {
+			return true
+		}
+	}
+	return false
+}
+
+func UpdateAutoGroupsByJsonString(jsonString string) error {
+	AutoGroups = make([]string, 0)
+	return json.Unmarshal([]byte(jsonString), &AutoGroups)
+}
+
+func AutoGroups2JsonString() string {
+	jsonBytes, err := json.Marshal(AutoGroups)
+	if err != nil {
+		return "[]"
+	}
+	return string(jsonBytes)
+}
--- a/setting/chat.go
+++ b/setting/chat.go
@@ -0,0 +1,41 @@
+package setting
+
+import (
+	"encoding/json"
+	"one-api/common"
+)
+
+var Chats = []map[string]string{
+	//{
+	//	"ChatGPT Next Web 官方示例": "https://app.nextchat.dev/#/?settings={\"key\":\"{key}\",\"url\":\"{address}\"}",
+	//},
+	{
+		"Cherry Studio": "cherrystudio://providers/api-keys?v=1&data={cherryConfig}",
+	},
+	{
+		"Lobe Chat 官方示例": "https://chat-preview.lobehub.com/?settings={\"keyVaults\":{\"openai\":{\"apiKey\":\"{key}\",\"baseURL\":\"{address}/v1\"}}}",
+	},
+	{
+		"AI as Workspace": "https://aiaw.app/set-provider?provider={\"type\":\"openai\",\"settings\":{\"apiKey\":\"{key}\",\"baseURL\":\"{address}/v1\",\"compatibility\":\"strict\"}}",
+	},
+	{
+		"AMA 问天": "ama://set-api-key?server={address}&key={key}",
+	},
+	{
+		"OpenCat": "opencat://team/join?domain={address}&token={key}",
+	},
+}
+
+func UpdateChatsByJsonString(jsonString string) error {
+	Chats = make([]map[string]string, 0)
+	return json.Unmarshal([]byte(jsonString), &Chats)
+}
+
+func Chats2JsonString() string {
+	jsonBytes, err := json.Marshal(Chats)
+	if err != nil {
+		common.SysError("error marshalling chats: " + err.Error())
+		return "[]"
+	}
+	return string(jsonBytes)
+}
--- a/setting/config/config.go
+++ b/setting/config/config.go
@@ -0,0 +1,259 @@
+package config
+
+import (
+	"encoding/json"
+	"one-api/common"
+	"reflect"
+	"strconv"
+	"strings"
+	"sync"
+)
+
+// ConfigManager 统一管理所有配置
+type ConfigManager struct {
+	configs map[string]interface{}
+	mutex   sync.RWMutex
+}
+
+var GlobalConfig = NewConfigManager()
+
+func NewConfigManager() *ConfigManager {
+	return &ConfigManager{
+		configs: make(map[string]interface{}),
+	}
+}
+
+// Register 注册一个配置模块
+func (cm *ConfigManager) Register(name string, config interface{}) {
+	cm.mutex.Lock()
+	defer cm.mutex.Unlock()
+	cm.configs[name] = config
+}
+
+// Get 获取指定配置模块
+func (cm *ConfigManager) Get(name string) interface{} {
+	cm.mutex.RLock()
+	defer cm.mutex.RUnlock()
+	return cm.configs[name]
+}
+
+// LoadFromDB 从数据库加载配置
+func (cm *ConfigManager) LoadFromDB(options map[string]string) error {
+	cm.mutex.Lock()
+	defer cm.mutex.Unlock()
+
+	for name, config := range cm.configs {
+		prefix := name + "."
+		configMap := make(map[string]string)
+
+		// 收集属于此配置的所有选项
+		for key, value := range options {
+			if strings.HasPrefix(key, prefix) {
+				configKey := strings.TrimPrefix(key, prefix)
+				configMap[configKey] = value
+			}
+		}
+
+		// 如果找到配置项，则更新配置
+		if len(configMap) > 0 {
+			if err := updateConfigFromMap(config, configMap); err != nil {
+				common.SysError("failed to update config " + name + ": " + err.Error())
+				continue
+			}
+		}
+	}
+
+	return nil
+}
+
+// SaveToDB 将配置保存到数据库
+func (cm *ConfigManager) SaveToDB(updateFunc func(key, value string) error) error {
+	cm.mutex.RLock()
+	defer cm.mutex.RUnlock()
+
+	for name, config := range cm.configs {
+		configMap, err := configToMap(config)
+		if err != nil {
+			return err
+		}
+
+		for key, value := range configMap {
+			dbKey := name + "." + key
+			if err := updateFunc(dbKey, value); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+// 辅助函数：将配置对象转换为map
+func configToMap(config interface{}) (map[string]string, error) {
+	result := make(map[string]string)
+
+	val := reflect.ValueOf(config)
+	if val.Kind() == reflect.Ptr {
+		val = val.Elem()
+	}
+
+	if val.Kind() != reflect.Struct {
+		return nil, nil
+	}
+
+	typ := val.Type()
+	for i := 0; i < val.NumField(); i++ {
+		field := val.Field(i)
+		fieldType := typ.Field(i)
+
+		// 跳过未导出字段
+		if !fieldType.IsExported() {
+			continue
+		}
+
+		// 获取json标签作为键名
+		key := fieldType.Tag.Get("json")
+		if key == "" || key == "-" {
+			key = fieldType.Name
+		}
+
+		// 处理不同类型的字段
+		var strValue string
+		switch field.Kind() {
+		case reflect.String:
+			strValue = field.String()
+		case reflect.Bool:
+			strValue = strconv.FormatBool(field.Bool())
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			strValue = strconv.FormatInt(field.Int(), 10)
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+			strValue = strconv.FormatUint(field.Uint(), 10)
+		case reflect.Float32, reflect.Float64:
+			strValue = strconv.FormatFloat(field.Float(), 'f', -1, 64)
+		case reflect.Map, reflect.Slice, reflect.Struct:
+			// 复杂类型使用JSON序列化
+			bytes, err := json.Marshal(field.Interface())
+			if err != nil {
+				return nil, err
+			}
+			strValue = string(bytes)
+		default:
+			// 跳过不支持的类型
+			continue
+		}
+
+		result[key] = strValue
+	}
+
+	return result, nil
+}
+
+// 辅助函数：从map更新配置对象
+func updateConfigFromMap(config interface{}, configMap map[string]string) error {
+	val := reflect.ValueOf(config)
+	if val.Kind() != reflect.Ptr {
+		return nil
+	}
+	val = val.Elem()
+
+	if val.Kind() != reflect.Struct {
+		return nil
+	}
+
+	typ := val.Type()
+	for i := 0; i < val.NumField(); i++ {
+		field := val.Field(i)
+		fieldType := typ.Field(i)
+
+		// 跳过未导出字段
+		if !fieldType.IsExported() {
+			continue
+		}
+
+		// 获取json标签作为键名
+		key := fieldType.Tag.Get("json")
+		if key == "" || key == "-" {
+			key = fieldType.Name
+		}
+
+		// 检查map中是否有对应的值
+		strValue, ok := configMap[key]
+		if !ok {
+			continue
+		}
+
+		// 根据字段类型设置值
+		if !field.CanSet() {
+			continue
+		}
+
+		switch field.Kind() {
+		case reflect.String:
+			field.SetString(strValue)
+		case reflect.Bool:
+			boolValue, err := strconv.ParseBool(strValue)
+			if err != nil {
+				continue
+			}
+			field.SetBool(boolValue)
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			intValue, err := strconv.ParseInt(strValue, 10, 64)
+			if err != nil {
+				continue
+			}
+			field.SetInt(intValue)
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+			uintValue, err := strconv.ParseUint(strValue, 10, 64)
+			if err != nil {
+				continue
+			}
+			field.SetUint(uintValue)
+		case reflect.Float32, reflect.Float64:
+			floatValue, err := strconv.ParseFloat(strValue, 64)
+			if err != nil {
+				continue
+			}
+			field.SetFloat(floatValue)
+		case reflect.Map, reflect.Slice, reflect.Struct:
+			// 复杂类型使用JSON反序列化
+			err := json.Unmarshal([]byte(strValue), field.Addr().Interface())
+			if err != nil {
+				continue
+			}
+		}
+	}
+
+	return nil
+}
+
+// ConfigToMap 将配置对象转换为map（导出函数）
+func ConfigToMap(config interface{}) (map[string]string, error) {
+	return configToMap(config)
+}
+
+// UpdateConfigFromMap 从map更新配置对象（导出函数）
+func UpdateConfigFromMap(config interface{}, configMap map[string]string) error {
+	return updateConfigFromMap(config, configMap)
+}
+
+// ExportAllConfigs 导出所有已注册的配置为扁平结构
+func (cm *ConfigManager) ExportAllConfigs() map[string]string {
+	cm.mutex.RLock()
+	defer cm.mutex.RUnlock()
+
+	result := make(map[string]string)
+
+	for name, cfg := range cm.configs {
+		configMap, err := ConfigToMap(cfg)
+		if err != nil {
+			continue
+		}
+
+		// 使用 "模块名.配置项" 的格式添加到结果中
+		for key, value := range configMap {
+			result[name+"."+key] = value
+		}
+	}
+
+	return result
+}
--- a/setting/console_setting/config.go
+++ b/setting/console_setting/config.go
@@ -0,0 +1,39 @@
+package console_setting
+
+import "one-api/setting/config"
+
+type ConsoleSetting struct {
+    ApiInfo           string `json:"api_info"`           // 控制台 API 信息 (JSON 数组字符串)
+    UptimeKumaGroups  string `json:"uptime_kuma_groups"` // Uptime Kuma 分组配置 (JSON 数组字符串)
+    Announcements     string `json:"announcements"`      // 系统公告 (JSON 数组字符串)
+    FAQ               string `json:"faq"`                // 常见问题 (JSON 数组字符串)
+    ApiInfoEnabled        bool `json:"api_info_enabled"`        // 是否启用 API 信息面板
+    UptimeKumaEnabled     bool `json:"uptime_kuma_enabled"`     // 是否启用 Uptime Kuma 面板
+    AnnouncementsEnabled  bool `json:"announcements_enabled"`   // 是否启用系统公告面板
+    FAQEnabled            bool `json:"faq_enabled"`             // 是否启用常见问答面板
+}
+
+// 默认配置
+var defaultConsoleSetting = ConsoleSetting{
+    ApiInfo:          "",
+    UptimeKumaGroups: "",
+    Announcements:    "",
+    FAQ:              "",
+    ApiInfoEnabled:       true,
+    UptimeKumaEnabled:    true,
+    AnnouncementsEnabled: true,
+    FAQEnabled:           true,
+}
+
+// 全局实例
+var consoleSetting = defaultConsoleSetting
+
+func init() {
+    // 注册到全局配置管理器，键名为 console_setting
+    config.GlobalConfig.Register("console_setting", &consoleSetting)
+}
+
+// GetConsoleSetting 获取 ConsoleSetting 配置实例
+func GetConsoleSetting() *ConsoleSetting {
+    return &consoleSetting
+} 
--- a/setting/console_setting/validation.go
+++ b/setting/console_setting/validation.go
@@ -0,0 +1,304 @@
+package console_setting
+
+import (
+    "encoding/json"
+    "fmt"
+    "net/url"
+    "regexp"
+    "strings"
+    "time"
+    "sort"
+)
+
+var (
+    urlRegex = regexp.MustCompile(`^https?://(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)*[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?|(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))(?:\:[0-9]{1,5})?(?:/.*)?$`)
+    dangerousChars = []string{"<script", "<iframe", "javascript:", "onload=", "onerror=", "onclick="}
+    validColors = map[string]bool{
+        "blue": true, "green": true, "cyan": true, "purple": true, "pink": true,
+        "red": true, "orange": true, "amber": true, "yellow": true, "lime": true,
+        "light-green": true, "teal": true, "light-blue": true, "indigo": true,
+        "violet": true, "grey": true,
+    }
+    slugRegex = regexp.MustCompile(`^[a-zA-Z0-9_-]+$`)
+)
+
+func parseJSONArray(jsonStr string, typeName string) ([]map[string]interface{}, error) {
+    var list []map[string]interface{}
+    if err := json.Unmarshal([]byte(jsonStr), &list); err != nil {
+        return nil, fmt.Errorf("%s格式错误：%s", typeName, err.Error())
+    }
+    return list, nil
+}
+
+func validateURL(urlStr string, index int, itemType string) error {
+    if !urlRegex.MatchString(urlStr) {
+        return fmt.Errorf("第%d个%s的URL格式不正确", index, itemType)
+    }
+    if _, err := url.Parse(urlStr); err != nil {
+        return fmt.Errorf("第%d个%s的URL无法解析：%s", index, itemType, err.Error())
+    }
+    return nil
+}
+
+func checkDangerousContent(content string, index int, itemType string) error {
+    lower := strings.ToLower(content)
+    for _, d := range dangerousChars {
+        if strings.Contains(lower, d) {
+            return fmt.Errorf("第%d个%s包含不允许的内容", index, itemType)
+        }
+    }
+    return nil
+}
+
+func getJSONList(jsonStr string) []map[string]interface{} {
+    if jsonStr == "" {
+        return []map[string]interface{}{}
+    }
+    var list []map[string]interface{}
+    json.Unmarshal([]byte(jsonStr), &list)
+    return list
+}
+
+func ValidateConsoleSettings(settingsStr string, settingType string) error {
+    if settingsStr == "" {
+        return nil
+    }
+
+    switch settingType {
+    case "ApiInfo":
+        return validateApiInfo(settingsStr)
+    case "Announcements":
+        return validateAnnouncements(settingsStr)
+    case "FAQ":
+        return validateFAQ(settingsStr)
+    case "UptimeKumaGroups":
+        return validateUptimeKumaGroups(settingsStr)
+    default:
+        return fmt.Errorf("未知的设置类型：%s", settingType)
+    }
+}
+
+func validateApiInfo(apiInfoStr string) error {
+    apiInfoList, err := parseJSONArray(apiInfoStr, "API信息")
+    if err != nil {
+        return err
+    }
+
+    if len(apiInfoList) > 50 {
+        return fmt.Errorf("API信息数量不能超过50个")
+    }
+
+    for i, apiInfo := range apiInfoList {
+        urlStr, ok := apiInfo["url"].(string)
+        if !ok || urlStr == "" {
+            return fmt.Errorf("第%d个API信息缺少URL字段", i+1)
+        }
+        route, ok := apiInfo["route"].(string)
+        if !ok || route == "" {
+            return fmt.Errorf("第%d个API信息缺少线路描述字段", i+1)
+        }
+        description, ok := apiInfo["description"].(string)
+        if !ok || description == "" {
+            return fmt.Errorf("第%d个API信息缺少说明字段", i+1)
+        }
+        color, ok := apiInfo["color"].(string)
+        if !ok || color == "" {
+            return fmt.Errorf("第%d个API信息缺少颜色字段", i+1)
+        }
+
+        if err := validateURL(urlStr, i+1, "API信息"); err != nil {
+            return err
+        }
+
+        if len(urlStr) > 500 {
+            return fmt.Errorf("第%d个API信息的URL长度不能超过500字符", i+1)
+        }
+        if len(route) > 100 {
+            return fmt.Errorf("第%d个API信息的线路描述长度不能超过100字符", i+1)
+        }
+        if len(description) > 200 {
+            return fmt.Errorf("第%d个API信息的说明长度不能超过200字符", i+1)
+        }
+
+        if !validColors[color] {
+            return fmt.Errorf("第%d个API信息的颜色值不合法", i+1)
+        }
+
+        if err := checkDangerousContent(description, i+1, "API信息"); err != nil {
+            return err
+        }
+        if err := checkDangerousContent(route, i+1, "API信息"); err != nil {
+            return err
+        }
+    }
+    return nil
+}
+
+func GetApiInfo() []map[string]interface{} {
+    return getJSONList(GetConsoleSetting().ApiInfo)
+}
+
+func validateAnnouncements(announcementsStr string) error {
+    list, err := parseJSONArray(announcementsStr, "系统公告")
+    if err != nil {
+        return err
+    }
+    if len(list) > 100 {
+        return fmt.Errorf("系统公告数量不能超过100个")
+    }
+    validTypes := map[string]bool{
+        "default": true, "ongoing": true, "success": true, "warning": true, "error": true,
+    }
+    for i, ann := range list {
+        content, ok := ann["content"].(string)
+        if !ok || content == "" {
+            return fmt.Errorf("第%d个公告缺少内容字段", i+1)
+        }
+        publishDateAny, exists := ann["publishDate"]
+        if !exists {
+            return fmt.Errorf("第%d个公告缺少发布日期字段", i+1)
+        }
+        publishDateStr, ok := publishDateAny.(string)
+        if !ok || publishDateStr == "" {
+            return fmt.Errorf("第%d个公告的发布日期不能为空", i+1)
+        }
+        if _, err := time.Parse(time.RFC3339, publishDateStr); err != nil {
+            return fmt.Errorf("第%d个公告的发布日期格式错误", i+1)
+        }
+        if t, exists := ann["type"]; exists {
+            if typeStr, ok := t.(string); ok {
+                if !validTypes[typeStr] {
+                    return fmt.Errorf("第%d个公告的类型值不合法", i+1)
+                }
+            }
+        }
+        if len(content) > 500 {
+            return fmt.Errorf("第%d个公告的内容长度不能超过500字符", i+1)
+        }
+        if extra, exists := ann["extra"]; exists {
+            if extraStr, ok := extra.(string); ok && len(extraStr) > 200 {
+                return fmt.Errorf("第%d个公告的说明长度不能超过200字符", i+1)
+            }
+        }
+    }
+    return nil
+}
+
+func validateFAQ(faqStr string) error {
+    list, err := parseJSONArray(faqStr, "FAQ信息")
+    if err != nil {
+        return err
+    }
+    if len(list) > 100 {
+        return fmt.Errorf("FAQ数量不能超过100个")
+    }
+    for i, faq := range list {
+        question, ok := faq["question"].(string)
+        if !ok || question == "" {
+            return fmt.Errorf("第%d个FAQ缺少问题字段", i+1)
+        }
+        answer, ok := faq["answer"].(string)
+        if !ok || answer == "" {
+            return fmt.Errorf("第%d个FAQ缺少答案字段", i+1)
+        }
+        if len(question) > 200 {
+            return fmt.Errorf("第%d个FAQ的问题长度不能超过200字符", i+1)
+        }
+        if len(answer) > 1000 {
+            return fmt.Errorf("第%d个FAQ的答案长度不能超过1000字符", i+1)
+        }
+    }
+    return nil
+}
+
+func getPublishTime(item map[string]interface{}) time.Time {
+    if v, ok := item["publishDate"]; ok {
+        if s, ok2 := v.(string); ok2 {
+            if t, err := time.Parse(time.RFC3339, s); err == nil {
+                return t
+            }
+        }
+    }
+    return time.Time{}
+}
+
+func GetAnnouncements() []map[string]interface{} {
+    list := getJSONList(GetConsoleSetting().Announcements)
+    sort.SliceStable(list, func(i, j int) bool {
+        return getPublishTime(list[i]).After(getPublishTime(list[j]))
+    })
+    return list
+}
+
+func GetFAQ() []map[string]interface{} {
+    return getJSONList(GetConsoleSetting().FAQ)
+}
+
+func validateUptimeKumaGroups(groupsStr string) error {
+    groups, err := parseJSONArray(groupsStr, "Uptime Kuma分组配置")
+    if err != nil {
+        return err
+    }
+
+    if len(groups) > 20 {
+        return fmt.Errorf("Uptime Kuma分组数量不能超过20个")
+    }
+
+    nameSet := make(map[string]bool)
+
+    for i, group := range groups {
+        categoryName, ok := group["categoryName"].(string)
+        if !ok || categoryName == "" {
+            return fmt.Errorf("第%d个分组缺少分类名称字段", i+1)
+        }
+        if nameSet[categoryName] {
+            return fmt.Errorf("第%d个分组的分类名称与其他分组重复", i+1)
+        }
+        nameSet[categoryName] = true
+        urlStr, ok := group["url"].(string)
+        if !ok || urlStr == "" {
+            return fmt.Errorf("第%d个分组缺少URL字段", i+1)
+        }
+        slug, ok := group["slug"].(string)
+        if !ok || slug == "" {
+            return fmt.Errorf("第%d个分组缺少Slug字段", i+1)
+        }
+        description, ok := group["description"].(string)
+        if !ok {
+            description = ""
+        }
+
+        if err := validateURL(urlStr, i+1, "分组"); err != nil {
+            return err
+        }
+
+        if len(categoryName) > 50 {
+            return fmt.Errorf("第%d个分组的分类名称长度不能超过50字符", i+1)
+        }
+        if len(urlStr) > 500 {
+            return fmt.Errorf("第%d个分组的URL长度不能超过500字符", i+1)
+        }
+        if len(slug) > 100 {
+            return fmt.Errorf("第%d个分组的Slug长度不能超过100字符", i+1)
+        }
+        if len(description) > 200 {
+            return fmt.Errorf("第%d个分组的描述长度不能超过200字符", i+1)
+        }
+
+        if !slugRegex.MatchString(slug) {
+            return fmt.Errorf("第%d个分组的Slug只能包含字母、数字、下划线和连字符", i+1)
+        }
+
+        if err := checkDangerousContent(description, i+1, "分组"); err != nil {
+            return err
+        }
+        if err := checkDangerousContent(categoryName, i+1, "分组"); err != nil {
+            return err
+        }
+    }
+    return nil
+}
+
+func GetUptimeKumaGroups() []map[string]interface{} {
+    return getJSONList(GetConsoleSetting().UptimeKumaGroups)
+} 
--- a/setting/midjourney.go
+++ b/setting/midjourney.go
@@ -0,0 +1,7 @@
+package setting
+
+var MjNotifyEnabled = false
+var MjAccountFilterEnabled = false
+var MjModeClearEnabled = false
+var MjForwardUrlEnabled = true
+var MjActionCheckSuccessEnabled = true
--- a/setting/model_setting/claude.go
+++ b/setting/model_setting/claude.go
@@ -0,0 +1,65 @@
+package model_setting
+
+import (
+	"net/http"
+	"one-api/setting/config"
+)
+
+//var claudeHeadersSettings = map[string][]string{}
+//
+//var ClaudeThinkingAdapterEnabled = true
+//var ClaudeThinkingAdapterMaxTokens = 8192
+//var ClaudeThinkingAdapterBudgetTokensPercentage = 0.8
+
+// ClaudeSettings 定义Claude模型的配置
+type ClaudeSettings struct {
+	HeadersSettings                       map[string]map[string][]string `json:"model_headers_settings"`
+	DefaultMaxTokens                      map[string]int                 `json:"default_max_tokens"`
+	ThinkingAdapterEnabled                bool                           `json:"thinking_adapter_enabled"`
+	ThinkingAdapterBudgetTokensPercentage float64                        `json:"thinking_adapter_budget_tokens_percentage"`
+}
+
+// 默认配置
+var defaultClaudeSettings = ClaudeSettings{
+	HeadersSettings:        map[string]map[string][]string{},
+	ThinkingAdapterEnabled: true,
+	DefaultMaxTokens: map[string]int{
+		"default": 8192,
+	},
+	ThinkingAdapterBudgetTokensPercentage: 0.8,
+}
+
+// 全局实例
+var claudeSettings = defaultClaudeSettings
+
+func init() {
+	// 注册到全局配置管理器
+	config.GlobalConfig.Register("claude", &claudeSettings)
+}
+
+// GetClaudeSettings 获取Claude配置
+func GetClaudeSettings() *ClaudeSettings {
+	// check default max tokens must have default key
+	if _, ok := claudeSettings.DefaultMaxTokens["default"]; !ok {
+		claudeSettings.DefaultMaxTokens["default"] = 8192
+	}
+	return &claudeSettings
+}
+
+func (c *ClaudeSettings) WriteHeaders(originModel string, httpHeader *http.Header) {
+	if headers, ok := c.HeadersSettings[originModel]; ok {
+		for headerKey, headerValues := range headers {
+			httpHeader.Del(headerKey)
+			for _, headerValue := range headerValues {
+				httpHeader.Add(headerKey, headerValue)
+			}
+		}
+	}
+}
+
+func (c *ClaudeSettings) GetDefaultMaxTokens(model string) int {
+	if maxTokens, ok := c.DefaultMaxTokens[model]; ok {
+		return maxTokens
+	}
+	return c.DefaultMaxTokens["default"]
+}
--- a/setting/model_setting/gemini.go
+++ b/setting/model_setting/gemini.go
@@ -0,0 +1,70 @@
+package model_setting
+
+import (
+	"one-api/setting/config"
+)
+
+// GeminiSettings 定义Gemini模型的配置
+type GeminiSettings struct {
+	SafetySettings                        map[string]string `json:"safety_settings"`
+	VersionSettings                       map[string]string `json:"version_settings"`
+	SupportedImagineModels                []string          `json:"supported_imagine_models"`
+	ThinkingAdapterEnabled                bool              `json:"thinking_adapter_enabled"`
+	ThinkingAdapterBudgetTokensPercentage float64           `json:"thinking_adapter_budget_tokens_percentage"`
+}
+
+// 默认配置
+var defaultGeminiSettings = GeminiSettings{
+	SafetySettings: map[string]string{
+		"default":                       "OFF",
+		"HARM_CATEGORY_CIVIC_INTEGRITY": "BLOCK_NONE",
+	},
+	VersionSettings: map[string]string{
+		"default":        "v1beta",
+		"gemini-1.0-pro": "v1",
+	},
+	SupportedImagineModels: []string{
+		"gemini-2.0-flash-exp-image-generation",
+		"gemini-2.0-flash-exp",
+	},
+	ThinkingAdapterEnabled:                false,
+	ThinkingAdapterBudgetTokensPercentage: 0.6,
+}
+
+// 全局实例
+var geminiSettings = defaultGeminiSettings
+
+func init() {
+	// 注册到全局配置管理器
+	config.GlobalConfig.Register("gemini", &geminiSettings)
+}
+
+// GetGeminiSettings 获取Gemini配置
+func GetGeminiSettings() *GeminiSettings {
+	return &geminiSettings
+}
+
+// GetGeminiSafetySetting 获取安全设置
+func GetGeminiSafetySetting(key string) string {
+	if value, ok := geminiSettings.SafetySettings[key]; ok {
+		return value
+	}
+	return geminiSettings.SafetySettings["default"]
+}
+
+// GetGeminiVersionSetting 获取版本设置
+func GetGeminiVersionSetting(key string) string {
+	if value, ok := geminiSettings.VersionSettings[key]; ok {
+		return value
+	}
+	return geminiSettings.VersionSettings["default"]
+}
+
+func IsGeminiModelSupportImagine(model string) bool {
+	for _, v := range geminiSettings.SupportedImagineModels {
+		if v == model {
+			return true
+		}
+	}
+	return false
+}
--- a/setting/model_setting/global.go
+++ b/setting/model_setting/global.go
@@ -0,0 +1,26 @@
+package model_setting
+
+import (
+	"one-api/setting/config"
+)
+
+type GlobalSettings struct {
+	PassThroughRequestEnabled bool `json:"pass_through_request_enabled"`
+}
+
+// 默认配置
+var defaultOpenaiSettings = GlobalSettings{
+	PassThroughRequestEnabled: false,
+}
+
+// 全局实例
+var globalSettings = defaultOpenaiSettings
+
+func init() {
+	// 注册到全局配置管理器
+	config.GlobalConfig.Register("global", &globalSettings)
+}
+
+func GetGlobalSettings() *GlobalSettings {
+	return &globalSettings
+}
--- a/setting/operation_setting/general_setting.go
+++ b/setting/operation_setting/general_setting.go
@@ -0,0 +1,25 @@
+package operation_setting
+
+import "one-api/setting/config"
+
+type GeneralSetting struct {
+	DocsLink            string `json:"docs_link"`
+	PingIntervalEnabled bool   `json:"ping_interval_enabled"`
+	PingIntervalSeconds int    `json:"ping_interval_seconds"`
+}
+
+// 默认配置
+var generalSetting = GeneralSetting{
+	DocsLink:            "https://docs.newapi.pro",
+	PingIntervalEnabled: false,
+	PingIntervalSeconds: 60,
+}
+
+func init() {
+	// 注册到全局配置管理器
+	config.GlobalConfig.Register("general_setting", &generalSetting)
+}
+
+func GetGeneralSetting() *GeneralSetting {
+	return &generalSetting
+}
--- a/setting/operation_setting/operation_setting.go
+++ b/setting/operation_setting/operation_setting.go
@@ -0,0 +1,32 @@
+package operation_setting
+
+import "strings"
+
+var DemoSiteEnabled = false
+var SelfUseModeEnabled = false
+
+var AutomaticDisableKeywords = []string{
+	"Your credit balance is too low",
+	"This organization has been disabled.",
+	"You exceeded your current quota",
+	"Permission denied",
+	"The security token included in the request is invalid",
+	"Operation not allowed",
+	"Your account is not authorized",
+}
+
+func AutomaticDisableKeywordsToString() string {
+	return strings.Join(AutomaticDisableKeywords, "\n")
+}
+
+func AutomaticDisableKeywordsFromString(s string) {
+	AutomaticDisableKeywords = []string{}
+	ak := strings.Split(s, "\n")
+	for _, k := range ak {
+		k = strings.TrimSpace(k)
+		k = strings.ToLower(k)
+		if k != "" {
+			AutomaticDisableKeywords = append(AutomaticDisableKeywords, k)
+		}
+	}
+}
--- a/setting/operation_setting/tools.go
+++ b/setting/operation_setting/tools.go
@@ -0,0 +1,90 @@
+package operation_setting
+
+import "strings"
+
+const (
+	// Web search
+	WebSearchHighTierModelPriceLow    = 30.00
+	WebSearchHighTierModelPriceMedium = 35.00
+	WebSearchHighTierModelPriceHigh   = 50.00
+	WebSearchPriceLow                 = 25.00
+	WebSearchPriceMedium              = 27.50
+	WebSearchPriceHigh                = 30.00
+	// File search
+	FileSearchPrice = 2.5
+)
+
+const (
+	// Gemini Audio Input Price
+	Gemini25FlashPreviewInputAudioPrice     = 1.00
+	Gemini25FlashProductionInputAudioPrice  = 1.00 // for `gemini-2.5-flash`
+	Gemini25FlashLitePreviewInputAudioPrice = 0.50
+	Gemini25FlashNativeAudioInputAudioPrice = 3.00
+	Gemini20FlashInputAudioPrice            = 0.70
+)
+
+const (
+	// Claude Web search
+	ClaudeWebSearchPrice = 10.00
+)
+
+func GetClaudeWebSearchPricePerThousand() float64 {
+	return ClaudeWebSearchPrice
+}
+
+func GetWebSearchPricePerThousand(modelName string, contextSize string) float64 {
+	// 确定模型类型
+	// https://platform.openai.com/docs/pricing Web search 价格按模型类型和 search context size 收费
+	// gpt-4.1, gpt-4o, or gpt-4o-search-preview 更贵，gpt-4.1-mini, gpt-4o-mini, gpt-4o-mini-search-preview 更便宜
+	isHighTierModel := (strings.HasPrefix(modelName, "gpt-4.1") || strings.HasPrefix(modelName, "gpt-4o")) &&
+		!strings.Contains(modelName, "mini")
+	// 确定 search context size 对应的价格
+	var priceWebSearchPerThousandCalls float64
+	switch contextSize {
+	case "low":
+		if isHighTierModel {
+			priceWebSearchPerThousandCalls = WebSearchHighTierModelPriceLow
+		} else {
+			priceWebSearchPerThousandCalls = WebSearchPriceLow
+		}
+	case "medium":
+		if isHighTierModel {
+			priceWebSearchPerThousandCalls = WebSearchHighTierModelPriceMedium
+		} else {
+			priceWebSearchPerThousandCalls = WebSearchPriceMedium
+		}
+	case "high":
+		if isHighTierModel {
+			priceWebSearchPerThousandCalls = WebSearchHighTierModelPriceHigh
+		} else {
+			priceWebSearchPerThousandCalls = WebSearchPriceHigh
+		}
+	default:
+		// search context size 默认为 medium
+		if isHighTierModel {
+			priceWebSearchPerThousandCalls = WebSearchHighTierModelPriceMedium
+		} else {
+			priceWebSearchPerThousandCalls = WebSearchPriceMedium
+		}
+	}
+	return priceWebSearchPerThousandCalls
+}
+
+func GetFileSearchPricePerThousand() float64 {
+	return FileSearchPrice
+}
+
+func GetGeminiInputAudioPricePerMillionTokens(modelName string) float64 {
+	if strings.HasPrefix(modelName, "gemini-2.5-flash-preview-native-audio") {
+		return Gemini25FlashNativeAudioInputAudioPrice
+	} else if strings.HasPrefix(modelName, "gemini-2.5-flash-preview-lite") {
+		return Gemini25FlashLitePreviewInputAudioPrice
+	} else if strings.HasPrefix(modelName, "gemini-2.5-flash-preview") {
+		return Gemini25FlashPreviewInputAudioPrice
+	} else if strings.HasPrefix(modelName, "gemini-2.5-flash") {
+		return Gemini25FlashProductionInputAudioPrice
+	} else if strings.HasPrefix(modelName, "gemini-2.0-flash") {
+		return Gemini20FlashInputAudioPrice
+	}
+	return 0
+}
--- a/setting/payment.go
+++ b/setting/payment.go
@@ -0,0 +1,46 @@
+package setting
+
+import "encoding/json"
+
+var PayAddress = ""
+var CustomCallbackAddress = ""
+var EpayId = ""
+var EpayKey = ""
+var Price = 7.3
+var MinTopUp = 1
+var USDExchangeRate = 7.3
+
+var PayMethods = []map[string]string{
+	{
+		"name":  "支付宝",
+		"color": "rgba(var(--semi-blue-5), 1)",
+		"type":  "alipay",
+	},
+	{
+		"name":  "微信",
+		"color": "rgba(var(--semi-green-5), 1)",
+		"type":  "wxpay",
+	},
+}
+
+func UpdatePayMethodsByJsonString(jsonString string) error {
+	PayMethods = make([]map[string]string, 0)
+	return json.Unmarshal([]byte(jsonString), &PayMethods)
+}
+
+func PayMethods2JsonString() string {
+	jsonBytes, err := json.Marshal(PayMethods)
+	if err != nil {
+		return "[]"
+	}
+	return string(jsonBytes)
+}
+
+func ContainsPayMethod(method string) bool {
+	for _, payMethod := range PayMethods {
+		if payMethod["type"] == method {
+			return true
+		}
+	}
+	return false
+}
--- a/setting/payment_stripe.go
+++ b/setting/payment_stripe.go
@@ -0,0 +1,7 @@
+package setting
+
+var StripeApiSecret = ""
+var StripeWebhookSecret = ""
+var StripePriceId = ""
+var StripeUnitPrice = 8.0
+var StripeMinTopUp = 1
--- a/setting/rate_limit.go
+++ b/setting/rate_limit.go
@@ -0,0 +1,64 @@
+package setting
+
+import (
+	"encoding/json"
+	"fmt"
+	"one-api/common"
+	"sync"
+)
+
+var ModelRequestRateLimitEnabled = false
+var ModelRequestRateLimitDurationMinutes = 1
+var ModelRequestRateLimitCount = 0
+var ModelRequestRateLimitSuccessCount = 1000
+var ModelRequestRateLimitGroup = map[string][2]int{}
+var ModelRequestRateLimitMutex sync.RWMutex
+
+func ModelRequestRateLimitGroup2JSONString() string {
+	ModelRequestRateLimitMutex.RLock()
+	defer ModelRequestRateLimitMutex.RUnlock()
+
+	jsonBytes, err := json.Marshal(ModelRequestRateLimitGroup)
+	if err != nil {
+		common.SysError("error marshalling model ratio: " + err.Error())
+	}
+	return string(jsonBytes)
+}
+
+func UpdateModelRequestRateLimitGroupByJSONString(jsonStr string) error {
+	ModelRequestRateLimitMutex.RLock()
+	defer ModelRequestRateLimitMutex.RUnlock()
+
+	ModelRequestRateLimitGroup = make(map[string][2]int)
+	return json.Unmarshal([]byte(jsonStr), &ModelRequestRateLimitGroup)
+}
+
+func GetGroupRateLimit(group string) (totalCount, successCount int, found bool) {
+	ModelRequestRateLimitMutex.RLock()
+	defer ModelRequestRateLimitMutex.RUnlock()
+
+	if ModelRequestRateLimitGroup == nil {
+		return 0, 0, false
+	}
+
+	limits, found := ModelRequestRateLimitGroup[group]
+	if !found {
+		return 0, 0, false
+	}
+	return limits[0], limits[1], true
+}
+
+func CheckModelRequestRateLimitGroup(jsonStr string) error {
+	checkModelRequestRateLimitGroup := make(map[string][2]int)
+	err := json.Unmarshal([]byte(jsonStr), &checkModelRequestRateLimitGroup)
+	if err != nil {
+		return err
+	}
+	for group, limits := range checkModelRequestRateLimitGroup {
+		if limits[0] < 0 || limits[1] < 1 {
+			return fmt.Errorf("group %s has negative rate limit values: [%d, %d]", group, limits[0], limits[1])
+		}
+	}
+
+	return nil
+}
--- a/setting/ratio_setting/cache_ratio.go
+++ b/setting/ratio_setting/cache_ratio.go
@@ -0,0 +1,122 @@
+package ratio_setting
+
+import (
+	"encoding/json"
+	"one-api/common"
+	"sync"
+)
+
+var defaultCacheRatio = map[string]float64{
+	"gpt-4":                               0.5,
+	"o1":                                  0.5,
+	"o1-2024-12-17":                       0.5,
+	"o1-preview-2024-09-12":               0.5,
+	"o1-preview":                          0.5,
+	"o1-mini-2024-09-12":                  0.5,
+	"o1-mini":                             0.5,
+	"o3-mini":                             0.5,
+	"o3-mini-2025-01-31":                  0.5,
+	"gpt-4o-2024-11-20":                   0.5,
+	"gpt-4o-2024-08-06":                   0.5,
+	"gpt-4o":                              0.5,
+	"gpt-4o-mini-2024-07-18":              0.5,
+	"gpt-4o-mini":                         0.5,
+	"gpt-4o-realtime-preview":             0.5,
+	"gpt-4o-mini-realtime-preview":        0.5,
+	"gpt-4.5-preview":                     0.5,
+	"gpt-4.5-preview-2025-02-27":          0.5,
+	"deepseek-chat":                       0.25,
+	"deepseek-reasoner":                   0.25,
+	"deepseek-coder":                      0.25,
+	"claude-3-sonnet-20240229":            0.1,
+	"claude-3-opus-20240229":              0.1,
+	"claude-3-haiku-20240307":             0.1,
+	"claude-3-5-haiku-20241022":           0.1,
+	"claude-3-5-sonnet-20240620":          0.1,
+	"claude-3-5-sonnet-20241022":          0.1,
+	"claude-3-7-sonnet-20250219":          0.1,
+	"claude-3-7-sonnet-20250219-thinking": 0.1,
+	"claude-sonnet-4-20250514":            0.1,
+	"claude-sonnet-4-20250514-thinking":   0.1,
+	"claude-opus-4-20250514":              0.1,
+	"claude-opus-4-20250514-thinking":     0.1,
+}
+
+var defaultCreateCacheRatio = map[string]float64{
+	"claude-3-sonnet-20240229":            1.25,
+	"claude-3-opus-20240229":              1.25,
+	"claude-3-haiku-20240307":             1.25,
+	"claude-3-5-haiku-20241022":           1.25,
+	"claude-3-5-sonnet-20240620":          1.25,
+	"claude-3-5-sonnet-20241022":          1.25,
+	"claude-3-7-sonnet-20250219":          1.25,
+	"claude-3-7-sonnet-20250219-thinking": 1.25,
+	"claude-sonnet-4-20250514":            1.25,
+	"claude-sonnet-4-20250514-thinking":   1.25,
+	"claude-opus-4-20250514":              1.25,
+	"claude-opus-4-20250514-thinking":     1.25,
+}
+
+//var defaultCreateCacheRatio = map[string]float64{}
+
+var cacheRatioMap map[string]float64
+var cacheRatioMapMutex sync.RWMutex
+
+// GetCacheRatioMap returns the cache ratio map
+func GetCacheRatioMap() map[string]float64 {
+	cacheRatioMapMutex.RLock()
+	defer cacheRatioMapMutex.RUnlock()
+	return cacheRatioMap
+}
+
+// CacheRatio2JSONString converts the cache ratio map to a JSON string
+func CacheRatio2JSONString() string {
+	cacheRatioMapMutex.RLock()
+	defer cacheRatioMapMutex.RUnlock()
+	jsonBytes, err := json.Marshal(cacheRatioMap)
+	if err != nil {
+		common.SysError("error marshalling cache ratio: " + err.Error())
+	}
+	return string(jsonBytes)
+}
+
+// UpdateCacheRatioByJSONString updates the cache ratio map from a JSON string
+func UpdateCacheRatioByJSONString(jsonStr string) error {
+	cacheRatioMapMutex.Lock()
+	defer cacheRatioMapMutex.Unlock()
+	cacheRatioMap = make(map[string]float64)
+	err := json.Unmarshal([]byte(jsonStr), &cacheRatioMap)
+	if err == nil {
+		InvalidateExposedDataCache()
+	}
+	return err
+}
+
+// GetCacheRatio returns the cache ratio for a model
+func GetCacheRatio(name string) (float64, bool) {
+	cacheRatioMapMutex.RLock()
+	defer cacheRatioMapMutex.RUnlock()
+	ratio, ok := cacheRatioMap[name]
+	if !ok {
+		return 1, false // Default to 1 if not found
+	}
+	return ratio, true
+}
+
+func GetCreateCacheRatio(name string) (float64, bool) {
+	ratio, ok := defaultCreateCacheRatio[name]
+	if !ok {
+		return 1.25, false // Default to 1.25 if not found
+	}
+	return ratio, true
+}
+
+func GetCacheRatioCopy() map[string]float64 {
+	cacheRatioMapMutex.RLock()
+	defer cacheRatioMapMutex.RUnlock()
+	copyMap := make(map[string]float64, len(cacheRatioMap))
+	for k, v := range cacheRatioMap {
+		copyMap[k] = v
+	}
+	return copyMap
+}
--- a/setting/ratio_setting/expose_ratio.go
+++ b/setting/ratio_setting/expose_ratio.go
@@ -0,0 +1,17 @@
+package ratio_setting
+
+import "sync/atomic"
+
+var exposeRatioEnabled atomic.Bool
+
+func init() {
+    exposeRatioEnabled.Store(false)
+}
+
+func SetExposeRatioEnabled(enabled bool) {
+    exposeRatioEnabled.Store(enabled)
+}
+
+func IsExposeRatioEnabled() bool {
+    return exposeRatioEnabled.Load()
+} 
--- a/setting/ratio_setting/exposed_cache.go
+++ b/setting/ratio_setting/exposed_cache.go
@@ -0,0 +1,55 @@
+package ratio_setting
+
+import (
+    "sync"
+    "sync/atomic"
+    "time"
+
+    "github.com/gin-gonic/gin"
+)
+
+const exposedDataTTL = 30 * time.Second
+
+type exposedCache struct {
+    data      gin.H
+    expiresAt time.Time
+}
+
+var (
+    exposedData atomic.Value
+    rebuildMu   sync.Mutex
+)
+
+func InvalidateExposedDataCache() {
+    exposedData.Store((*exposedCache)(nil))
+}
+
+func cloneGinH(src gin.H) gin.H {
+    dst := make(gin.H, len(src))
+    for k, v := range src {
+        dst[k] = v
+    }
+    return dst
+}
+
+func GetExposedData() gin.H {
+    if c, ok := exposedData.Load().(*exposedCache); ok && c != nil && time.Now().Before(c.expiresAt) {
+        return cloneGinH(c.data)
+    }
+    rebuildMu.Lock()
+    defer rebuildMu.Unlock()
+    if c, ok := exposedData.Load().(*exposedCache); ok && c != nil && time.Now().Before(c.expiresAt) {
+        return cloneGinH(c.data)
+    }
+    newData := gin.H{
+        "model_ratio":      GetModelRatioCopy(),
+        "completion_ratio": GetCompletionRatioCopy(),
+        "cache_ratio":      GetCacheRatioCopy(),
+        "model_price":      GetModelPriceCopy(),
+    }
+    exposedData.Store(&exposedCache{
+        data:      newData,
+        expiresAt: time.Now().Add(exposedDataTTL),
+    })
+    return cloneGinH(newData)
+} 
--- a/setting/ratio_setting/group_ratio.go
+++ b/setting/ratio_setting/group_ratio.go
@@ -0,0 +1,122 @@
+package ratio_setting
+
+import (
+	"encoding/json"
+	"errors"
+	"one-api/common"
+	"sync"
+)
+
+var groupRatio = map[string]float64{
+	"default": 1,
+	"vip":     1,
+	"svip":    1,
+}
+var groupRatioMutex sync.RWMutex
+
+var (
+	GroupGroupRatio = map[string]map[string]float64{
+		"vip": {
+			"edit_this": 0.9,
+		},
+	}
+	groupGroupRatioMutex sync.RWMutex
+)
+
+func GetGroupRatioCopy() map[string]float64 {
+	groupRatioMutex.RLock()
+	defer groupRatioMutex.RUnlock()
+
+	groupRatioCopy := make(map[string]float64)
+	for k, v := range groupRatio {
+		groupRatioCopy[k] = v
+	}
+	return groupRatioCopy
+}
+
+func ContainsGroupRatio(name string) bool {
+	groupRatioMutex.RLock()
+	defer groupRatioMutex.RUnlock()
+
+	_, ok := groupRatio[name]
+	return ok
+}
+
+func GroupRatio2JSONString() string {
+	groupRatioMutex.RLock()
+	defer groupRatioMutex.RUnlock()
+
+	jsonBytes, err := json.Marshal(groupRatio)
+	if err != nil {
+		common.SysError("error marshalling model ratio: " + err.Error())
+	}
+	return string(jsonBytes)
+}
+
+func UpdateGroupRatioByJSONString(jsonStr string) error {
+	groupRatioMutex.Lock()
+	defer groupRatioMutex.Unlock()
+
+	groupRatio = make(map[string]float64)
+	return json.Unmarshal([]byte(jsonStr), &groupRatio)
+}
+
+func GetGroupRatio(name string) float64 {
+	groupRatioMutex.RLock()
+	defer groupRatioMutex.RUnlock()
+
+	ratio, ok := groupRatio[name]
+	if !ok {
+		common.SysError("group ratio not found: " + name)
+		return 1
+	}
+	return ratio
+}
+
+func GetGroupGroupRatio(userGroup, usingGroup string) (float64, bool) {
+	groupGroupRatioMutex.RLock()
+	defer groupGroupRatioMutex.RUnlock()
+
+	gp, ok := GroupGroupRatio[userGroup]
+	if !ok {
+		return -1, false
+	}
+	ratio, ok := gp[usingGroup]
+	if !ok {
+		return -1, false
+	}
+	return ratio, true
+}
+
+func GroupGroupRatio2JSONString() string {
+	groupGroupRatioMutex.RLock()
+	defer groupGroupRatioMutex.RUnlock()
+
+	jsonBytes, err := json.Marshal(GroupGroupRatio)
+	if err != nil {
+		common.SysError("error marshalling group-group ratio: " + err.Error())
+	}
+	return string(jsonBytes)
+}
+
+func UpdateGroupGroupRatioByJSONString(jsonStr string) error {
+	groupGroupRatioMutex.Lock()
+	defer groupGroupRatioMutex.Unlock()
+
+	GroupGroupRatio = make(map[string]map[string]float64)
+	return json.Unmarshal([]byte(jsonStr), &GroupGroupRatio)
+}
+
+func CheckGroupRatio(jsonStr string) error {
+	checkGroupRatio := make(map[string]float64)
+	err := json.Unmarshal([]byte(jsonStr), &checkGroupRatio)
+	if err != nil {
+		return err
+	}
+	for name, ratio := range checkGroupRatio {
+		if ratio < 0 {
+			return errors.New("group ratio must be not less than 0: " + name)
+		}
+	}
+	return nil
+}
--- a/setting/ratio_setting/model_ratio.go
+++ b/setting/ratio_setting/model_ratio.go
@@ -0,0 +1,665 @@
+package ratio_setting
+
+import (
+	"encoding/json"
+	"one-api/common"
+	"one-api/setting/operation_setting"
+	"strings"
+	"sync"
+)
+
+// from songquanpeng/one-api
+const (
+	USD2RMB = 7.3 // 暂定 1 USD = 7.3 RMB
+	USD     = 500 // $0.002 = 1 -> $1 = 500
+	RMB     = USD / USD2RMB
+)
+
+// 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 defaultModelRatio = map[string]float64{
+	//"midjourney":                50,
+	"gpt-4-gizmo-*":  15,
+	"gpt-4o-gizmo-*": 2.5,
+	"gpt-4-all":      15,
+	"gpt-4o-all":     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,    // $10 / 1M tokens
+	"gpt-4-0125-preview":                      5,    // $10 / 1M tokens
+	"gpt-4-turbo-preview":                     5,    // $10 / 1M tokens
+	"gpt-4-vision-preview":                    5,    // $10 / 1M tokens
+	"gpt-4-1106-vision-preview":               5,    // $10 / 1M tokens
+	"chatgpt-4o-latest":                       2.5,  // $5 / 1M tokens
+	"gpt-4o":                                  1.25, // $2.5 / 1M tokens
+	"gpt-4o-audio-preview":                    1.25, // $2.5 / 1M tokens
+	"gpt-4o-audio-preview-2024-10-01":         1.25, // $2.5 / 1M tokens
+	"gpt-4o-2024-05-13":                       2.5,  // $5 / 1M tokens
+	"gpt-4o-2024-08-06":                       1.25, // $2.5 / 1M tokens
+	"gpt-4o-2024-11-20":                       1.25, // $2.5 / 1M tokens
+	"gpt-4o-realtime-preview":                 2.5,
+	"gpt-4o-realtime-preview-2024-10-01":      2.5,
+	"gpt-4o-realtime-preview-2024-12-17":      2.5,
+	"gpt-4o-mini-realtime-preview":            0.3,
+	"gpt-4o-mini-realtime-preview-2024-12-17": 0.3,
+	"gpt-image-1":                             2.5,
+	"o1":                                      7.5,
+	"o1-2024-12-17":                           7.5,
+	"o1-preview":                              7.5,
+	"o1-preview-2024-09-12":                   7.5,
+	"o1-mini":                                 0.55,
+	"o1-mini-2024-09-12":                      0.55,
+	"o3-mini":                                 0.55,
+	"o3-mini-2025-01-31":                      0.55,
+	"o3-mini-high":                            0.55,
+	"o3-mini-2025-01-31-high":                 0.55,
+	"o3-mini-low":                             0.55,
+	"o3-mini-2025-01-31-low":                  0.55,
+	"o3-mini-medium":                          0.55,
+	"o3-mini-2025-01-31-medium":               0.55,
+	"gpt-4o-mini":                             0.075,
+	"gpt-4o-mini-2024-07-18":                  0.075,
+	"gpt-4-turbo":                             5, // $0.01 / 1K tokens
+	"gpt-4-turbo-2024-04-09":                  5, // $0.01 / 1K tokens
+	"gpt-4.5-preview":                         37.5,
+	"gpt-4.5-preview-2025-02-27":              37.5,
+	//"gpt-3.5-turbo-0301":           0.75, //deprecated
+	"gpt-3.5-turbo":          0.25,
+	"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,
+	"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-5-haiku-20241022":                 0.5,   // $1 / 1M tokens
+	"claude-3-sonnet-20240229":                  1.5,   // $3 / 1M tokens
+	"claude-3-5-sonnet-20240620":                1.5,
+	"claude-3-5-sonnet-20241022":                1.5,
+	"claude-3-7-sonnet-20250219":                1.5,
+	"claude-3-7-sonnet-20250219-thinking":       1.5,
+	"claude-sonnet-4-20250514":                  1.5,
+	"claude-3-opus-20240229":                    7.5, // $15 / 1M tokens
+	"claude-opus-4-20250514":                    7.5,
+	"ERNIE-4.0-8K":                              0.120 * RMB,
+	"ERNIE-3.5-8K":                              0.012 * RMB,
+	"ERNIE-3.5-8K-0205":                         0.024 * RMB,
+	"ERNIE-3.5-8K-1222":                         0.012 * RMB,
+	"ERNIE-Bot-8K":                              0.024 * RMB,
+	"ERNIE-3.5-4K-0205":                         0.012 * RMB,
+	"ERNIE-Speed-8K":                            0.004 * RMB,
+	"ERNIE-Speed-128K":                          0.004 * RMB,
+	"ERNIE-Lite-8K-0922":                        0.008 * RMB,
+	"ERNIE-Lite-8K-0308":                        0.003 * RMB,
+	"ERNIE-Tiny-8K":                             0.001 * RMB,
+	"BLOOMZ-7B":                                 0.004 * RMB,
+	"Embedding-V1":                              0.002 * RMB,
+	"bge-large-zh":                              0.002 * RMB,
+	"bge-large-en":                              0.002 * RMB,
+	"tao-8k":                                    0.002 * RMB,
+	"PaLM-2":                                    1,
+	"gemini-1.5-pro-latest":                     1.25, // $3.5 / 1M tokens
+	"gemini-1.5-flash-latest":                   0.075,
+	"gemini-2.0-flash":                          0.05,
+	"gemini-2.5-pro-exp-03-25":                  0.625,
+	"gemini-2.5-pro-preview-03-25":              0.625,
+	"gemini-2.5-pro":                            0.625,
+	"gemini-2.5-flash-preview-04-17":            0.075,
+	"gemini-2.5-flash-preview-04-17-thinking":   0.075,
+	"gemini-2.5-flash-preview-04-17-nothinking": 0.075,
+	"gemini-2.5-flash-preview-05-20":            0.075,
+	"gemini-2.5-flash-preview-05-20-thinking":   0.075,
+	"gemini-2.5-flash-preview-05-20-nothinking": 0.075,
+	"gemini-2.5-flash-thinking-*":               0.075, // 用于为后续所有2.5 flash thinking budget 模型设置默认倍率
+	"gemini-2.5-pro-thinking-*":                 0.625, // 用于为后续所有2.5 pro thinking budget 模型设置默认倍率
+	"gemini-2.5-flash-lite-preview-06-17":       0.05,
+	"gemini-2.5-flash":                          0.15,
+	"text-embedding-004":                        0.001,
+	"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":                                    0.05 * RMB, // ￥0.05 / 1k tokens
+	"glm-4-alltools":                            0.1 * RMB,  // ￥0.1 / 1k tokens
+	"glm-3-turbo":                               0.3572,
+	"glm-4-plus":                                0.05 * RMB,
+	"glm-4-0520":                                0.1 * RMB,
+	"glm-4-air":                                 0.001 * RMB,
+	"glm-4-airx":                                0.01 * RMB,
+	"glm-4-long":                                0.001 * RMB,
+	"glm-4-flash":                               0,
+	"glm-4v-plus":                               0.01 * RMB,
+	"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
+	"SparkDesk-v4.0":                            1.2858,
+	"360GPT_S2_V9":                              0.8572, // ¥0.012 / 1k tokens
+	"360gpt-turbo":                              0.0858, // ¥0.0012 / 1k tokens
+	"360gpt-turbo-responsibility-8k":            0.8572, // ¥0.012 / 1k tokens
+	"360gpt-pro":                                0.8572, // ¥0.012 / 1k tokens
+	"360gpt2-pro":                               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.18,
+	"yi-34b-chat-200k":       0.864,
+	"yi-vl-plus":             0.432,
+	"yi-large":               20.0 / 1000 * RMB,
+	"yi-medium":              2.5 / 1000 * RMB,
+	"yi-vision":              6.0 / 1000 * RMB,
+	"yi-medium-200k":         12.0 / 1000 * RMB,
+	"yi-spark":               1.0 / 1000 * RMB,
+	"yi-large-rag":           25.0 / 1000 * RMB,
+	"yi-large-turbo":         12.0 / 1000 * RMB,
+	"yi-large-preview":       20.0 / 1000 * RMB,
+	"yi-large-rag-preview":   25.0 / 1000 * RMB,
+	"command":                0.5,
+	"command-nightly":        0.5,
+	"command-light":          0.5,
+	"command-light-nightly":  0.5,
+	"command-r":              0.25,
+	"command-r-plus":         1.5,
+	"command-r-08-2024":      0.075,
+	"command-r-plus-08-2024": 1.25,
+	"deepseek-chat":          0.27 / 2,
+	"deepseek-coder":         0.27 / 2,
+	"deepseek-reasoner":      0.55 / 2, // 0.55 / 1k tokens
+	// Perplexity online 模型对搜索额外收费，有需要应自行调整，此处不计入搜索费用
+	"llama-3-sonar-small-32k-chat":   0.2 / 1000 * USD,
+	"llama-3-sonar-small-32k-online": 0.2 / 1000 * USD,
+	"llama-3-sonar-large-32k-chat":   1 / 1000 * USD,
+	"llama-3-sonar-large-32k-online": 1 / 1000 * USD,
+	// grok
+	"grok-3-beta":           1.5,
+	"grok-3-mini-beta":      0.15,
+	"grok-2":                1,
+	"grok-2-vision":         1,
+	"grok-beta":             2.5,
+	"grok-vision-beta":      2.5,
+	"grok-3-fast-beta":      2.5,
+	"grok-3-mini-fast-beta": 0.3,
+}
+
+var defaultModelPrice = map[string]float64{
+	"suno_music":              0.1,
+	"suno_lyrics":             0.01,
+	"dall-e-3":                0.04,
+	"imagen-3.0-generate-002": 0.03,
+	"gpt-4-gizmo-*":           0.1,
+	"mj_video":                0.8,
+	"mj_imagine":              0.1,
+	"mj_edits":                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,
+	"mj_upload":               0.05,
+}
+
+var (
+	modelPriceMap      map[string]float64 = nil
+	modelPriceMapMutex                    = sync.RWMutex{}
+)
+var (
+	modelRatioMap      map[string]float64 = nil
+	modelRatioMapMutex                    = sync.RWMutex{}
+)
+
+var (
+	CompletionRatio      map[string]float64 = nil
+	CompletionRatioMutex                    = sync.RWMutex{}
+)
+
+var defaultCompletionRatio = map[string]float64{
+	"gpt-4-gizmo-*":  2,
+	"gpt-4o-gizmo-*": 3,
+	"gpt-4-all":      2,
+	"gpt-image-1":    8,
+}
+
+// InitRatioSettings initializes all model related settings maps
+func InitRatioSettings() {
+	// Initialize modelPriceMap
+	modelPriceMapMutex.Lock()
+	modelPriceMap = defaultModelPrice
+	modelPriceMapMutex.Unlock()
+
+	// Initialize modelRatioMap
+	modelRatioMapMutex.Lock()
+	modelRatioMap = defaultModelRatio
+	modelRatioMapMutex.Unlock()
+
+	// Initialize CompletionRatio
+	CompletionRatioMutex.Lock()
+	CompletionRatio = defaultCompletionRatio
+	CompletionRatioMutex.Unlock()
+
+	// Initialize cacheRatioMap
+	cacheRatioMapMutex.Lock()
+	cacheRatioMap = defaultCacheRatio
+	cacheRatioMapMutex.Unlock()
+
+	// initialize imageRatioMap
+	imageRatioMapMutex.Lock()
+	imageRatioMap = defaultImageRatio
+	imageRatioMapMutex.Unlock()
+
+}
+
+func GetModelPriceMap() map[string]float64 {
+	modelPriceMapMutex.RLock()
+	defer modelPriceMapMutex.RUnlock()
+	return modelPriceMap
+}
+
+func ModelPrice2JSONString() string {
+	modelPriceMapMutex.RLock()
+	defer modelPriceMapMutex.RUnlock()
+
+	jsonBytes, err := json.Marshal(modelPriceMap)
+	if err != nil {
+		common.SysError("error marshalling model price: " + err.Error())
+	}
+	return string(jsonBytes)
+}
+
+func UpdateModelPriceByJSONString(jsonStr string) error {
+	modelPriceMapMutex.Lock()
+	defer modelPriceMapMutex.Unlock()
+	modelPriceMap = make(map[string]float64)
+	err := json.Unmarshal([]byte(jsonStr), &modelPriceMap)
+	if err == nil {
+		InvalidateExposedDataCache()
+	}
+	return err
+}
+
+// GetModelPrice 返回模型的价格，如果模型不存在则返回-1，false
+func GetModelPrice(name string, printErr bool) (float64, bool) {
+	modelPriceMapMutex.RLock()
+	defer modelPriceMapMutex.RUnlock()
+
+	if strings.HasPrefix(name, "gpt-4-gizmo") {
+		name = "gpt-4-gizmo-*"
+	}
+	if strings.HasPrefix(name, "gpt-4o-gizmo") {
+		name = "gpt-4o-gizmo-*"
+	}
+	price, ok := modelPriceMap[name]
+	if !ok {
+		if printErr {
+			common.SysError("model price not found: " + name)
+		}
+		return -1, false
+	}
+	return price, true
+}
+
+func UpdateModelRatioByJSONString(jsonStr string) error {
+	modelRatioMapMutex.Lock()
+	defer modelRatioMapMutex.Unlock()
+	modelRatioMap = make(map[string]float64)
+	err := json.Unmarshal([]byte(jsonStr), &modelRatioMap)
+	if err == nil {
+		InvalidateExposedDataCache()
+	}
+	return err
+}
+
+// 处理带有思考预算的模型名称，方便统一定价
+func handleThinkingBudgetModel(name, prefix, wildcard string) string {
+	if strings.HasPrefix(name, prefix) && strings.Contains(name, "-thinking-") {
+		return wildcard
+	}
+	return name
+}
+
+func GetModelRatio(name string) (float64, bool, string) {
+	modelRatioMapMutex.RLock()
+	defer modelRatioMapMutex.RUnlock()
+
+	name = handleThinkingBudgetModel(name, "gemini-2.5-flash", "gemini-2.5-flash-thinking-*")
+	name = handleThinkingBudgetModel(name, "gemini-2.5-pro", "gemini-2.5-pro-thinking-*")
+	if strings.HasPrefix(name, "gpt-4-gizmo") {
+		name = "gpt-4-gizmo-*"
+	}
+	ratio, ok := modelRatioMap[name]
+	if !ok {
+		return 37.5, operation_setting.SelfUseModeEnabled, name
+	}
+	return ratio, true, name
+}
+
+func DefaultModelRatio2JSONString() string {
+	jsonBytes, err := json.Marshal(defaultModelRatio)
+	if err != nil {
+		common.SysError("error marshalling model ratio: " + err.Error())
+	}
+	return string(jsonBytes)
+}
+
+func GetDefaultModelRatioMap() map[string]float64 {
+	return defaultModelRatio
+}
+
+func GetCompletionRatioMap() map[string]float64 {
+	CompletionRatioMutex.RLock()
+	defer CompletionRatioMutex.RUnlock()
+	return CompletionRatio
+}
+
+func CompletionRatio2JSONString() string {
+	CompletionRatioMutex.RLock()
+	defer CompletionRatioMutex.RUnlock()
+
+	jsonBytes, err := json.Marshal(CompletionRatio)
+	if err != nil {
+		common.SysError("error marshalling completion ratio: " + err.Error())
+	}
+	return string(jsonBytes)
+}
+
+func UpdateCompletionRatioByJSONString(jsonStr string) error {
+	CompletionRatioMutex.Lock()
+	defer CompletionRatioMutex.Unlock()
+	CompletionRatio = make(map[string]float64)
+	err := json.Unmarshal([]byte(jsonStr), &CompletionRatio)
+	if err == nil {
+		InvalidateExposedDataCache()
+	}
+	return err
+}
+
+func GetCompletionRatio(name string) float64 {
+	CompletionRatioMutex.RLock()
+	defer CompletionRatioMutex.RUnlock()
+	if strings.HasPrefix(name, "gpt-4-gizmo") {
+		name = "gpt-4-gizmo-*"
+	}
+	if strings.HasPrefix(name, "gpt-4o-gizmo") {
+		name = "gpt-4o-gizmo-*"
+	}
+	if strings.Contains(name, "/") {
+		if ratio, ok := CompletionRatio[name]; ok {
+			return ratio
+		}
+	}
+	hardCodedRatio, contain := getHardcodedCompletionModelRatio(name)
+	if contain {
+		return hardCodedRatio
+	}
+	if ratio, ok := CompletionRatio[name]; ok {
+		return ratio
+	}
+	return hardCodedRatio
+}
+
+func getHardcodedCompletionModelRatio(name string) (float64, bool) {
+	lowercaseName := strings.ToLower(name)
+	if strings.HasPrefix(name, "gpt-4") && !strings.HasSuffix(name, "-all") && !strings.HasSuffix(name, "-gizmo-*") {
+		if strings.HasPrefix(name, "gpt-4o") {
+			if name == "gpt-4o-2024-05-13" {
+				return 3, true
+			}
+			return 4, true
+		}
+		// gpt-4.5-preview匹配
+		if strings.HasPrefix(name, "gpt-4.5-preview") {
+			return 2, true
+		}
+		if strings.HasPrefix(name, "gpt-4-turbo") || strings.HasSuffix(name, "gpt-4-1106") || strings.HasSuffix(name, "gpt-4-1105") {
+			return 3, true
+		}
+		// 没有特殊标记的 gpt-4 模型默认倍率为 2
+		return 2, false
+	}
+	if strings.HasPrefix(name, "o1") || strings.HasPrefix(name, "o3") {
+		return 4, true
+	}
+	if name == "chatgpt-4o-latest" {
+		return 3, true
+	}
+
+	if strings.Contains(name, "claude-3") {
+		return 5, true
+	} else if strings.Contains(name, "claude-sonnet-4") || strings.Contains(name, "claude-opus-4") {
+		return 5, true
+	} else if strings.Contains(name, "claude-instant-1") || strings.Contains(name, "claude-2") {
+		return 3, true
+	}
+
+	if strings.HasPrefix(name, "gpt-3.5") {
+		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, true
+		}
+		if strings.HasSuffix(name, "1106") {
+			return 2, true
+		}
+		return 4.0 / 3.0, true
+	}
+	if strings.HasPrefix(name, "mistral-") {
+		return 3, true
+	}
+	if strings.HasPrefix(name, "gemini-") {
+		if strings.HasPrefix(name, "gemini-1.5") {
+			return 4, true
+		} else if strings.HasPrefix(name, "gemini-2.0") {
+			return 4, true
+		} else if strings.HasPrefix(name, "gemini-2.5-pro") { // 移除preview来增加兼容性，这里假设正式版的倍率和preview一致
+			return 8, false
+		} else if strings.HasPrefix(name, "gemini-2.5-flash") { // 处理不同的flash模型倍率
+			if strings.HasPrefix(name, "gemini-2.5-flash-preview") {
+				if strings.HasSuffix(name, "-nothinking") {
+					return 4, false
+				}
+				return 3.5 / 0.15, false
+			}
+			if strings.HasPrefix(name, "gemini-2.5-flash-lite") {
+				if strings.HasPrefix(name, "gemini-2.5-flash-lite-preview") {
+					return 4, false
+				}
+				return 4, false
+			}
+			return 2.5 / 0.3, true
+		}
+		return 4, false
+	}
+	if strings.HasPrefix(name, "command") {
+		switch name {
+		case "command-r":
+			return 3, true
+		case "command-r-plus":
+			return 5, true
+		case "command-r-08-2024":
+			return 4, true
+		case "command-r-plus-08-2024":
+			return 4, true
+		default:
+			return 4, false
+		}
+	}
+	// hint 只给官方上4倍率，由于开源模型供应商自行定价，不对其进行补全倍率进行强制对齐
+	if lowercaseName == "deepseek-chat" || lowercaseName == "deepseek-reasoner" {
+		return 4, true
+	}
+	if strings.HasPrefix(name, "ERNIE-Speed-") {
+		return 2, true
+	} else if strings.HasPrefix(name, "ERNIE-Lite-") {
+		return 2, true
+	} else if strings.HasPrefix(name, "ERNIE-Character") {
+		return 2, true
+	} else if strings.HasPrefix(name, "ERNIE-Functions") {
+		return 2, true
+	}
+	switch name {
+	case "llama2-70b-4096":
+		return 0.8 / 0.64, true
+	case "llama3-8b-8192":
+		return 2, true
+	case "llama3-70b-8192":
+		return 0.79 / 0.59, true
+	}
+	return 1, false
+}
+
+func GetAudioRatio(name string) float64 {
+	if strings.Contains(name, "-realtime") {
+		if strings.HasSuffix(name, "gpt-4o-realtime-preview") {
+			return 8
+		} else if strings.Contains(name, "gpt-4o-mini-realtime-preview") {
+			return 10 / 0.6
+		} else {
+			return 20
+		}
+	}
+	if strings.Contains(name, "-audio") {
+		if strings.HasPrefix(name, "gpt-4o-audio-preview") {
+			return 40 / 2.5
+		} else if strings.HasPrefix(name, "gpt-4o-mini-audio-preview") {
+			return 10 / 0.15
+		} else {
+			return 40
+		}
+	}
+	return 20
+}
+
+func GetAudioCompletionRatio(name string) float64 {
+	if strings.HasPrefix(name, "gpt-4o-realtime") {
+		return 2
+	} else if strings.HasPrefix(name, "gpt-4o-mini-realtime") {
+		return 2
+	}
+	return 2
+}
+
+func ModelRatio2JSONString() string {
+	modelRatioMapMutex.RLock()
+	defer modelRatioMapMutex.RUnlock()
+
+	jsonBytes, err := json.Marshal(modelRatioMap)
+	if err != nil {
+		common.SysError("error marshalling model ratio: " + err.Error())
+	}
+	return string(jsonBytes)
+}
+
+var defaultImageRatio = map[string]float64{
+	"gpt-image-1": 2,
+}
+var imageRatioMap map[string]float64
+var imageRatioMapMutex sync.RWMutex
+
+func ImageRatio2JSONString() string {
+	imageRatioMapMutex.RLock()
+	defer imageRatioMapMutex.RUnlock()
+	jsonBytes, err := json.Marshal(imageRatioMap)
+	if err != nil {
+		common.SysError("error marshalling cache ratio: " + err.Error())
+	}
+	return string(jsonBytes)
+}
+
+func UpdateImageRatioByJSONString(jsonStr string) error {
+	imageRatioMapMutex.Lock()
+	defer imageRatioMapMutex.Unlock()
+	imageRatioMap = make(map[string]float64)
+	return json.Unmarshal([]byte(jsonStr), &imageRatioMap)
+}
+
+func GetImageRatio(name string) (float64, bool) {
+	imageRatioMapMutex.RLock()
+	defer imageRatioMapMutex.RUnlock()
+	ratio, ok := imageRatioMap[name]
+	if !ok {
+		return 1, false // Default to 1 if not found
+	}
+	return ratio, true
+}
+
+func GetModelRatioCopy() map[string]float64 {
+	modelRatioMapMutex.RLock()
+	defer modelRatioMapMutex.RUnlock()
+	copyMap := make(map[string]float64, len(modelRatioMap))
+	for k, v := range modelRatioMap {
+		copyMap[k] = v
+	}
+	return copyMap
+}
+
+func GetModelPriceCopy() map[string]float64 {
+	modelPriceMapMutex.RLock()
+	defer modelPriceMapMutex.RUnlock()
+	copyMap := make(map[string]float64, len(modelPriceMap))
+	for k, v := range modelPriceMap {
+		copyMap[k] = v
+	}
+	return copyMap
+}
+
+func GetCompletionRatioCopy() map[string]float64 {
+	CompletionRatioMutex.RLock()
+	defer CompletionRatioMutex.RUnlock()
+	copyMap := make(map[string]float64, len(CompletionRatio))
+	for k, v := range CompletionRatio {
+		copyMap[k] = v
+	}
+	return copyMap
+}
--- a/setting/sensitive.go
+++ b/setting/sensitive.go
@@ -0,0 +1,43 @@
+package setting
+
+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_sensitive",
+}
+
+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/setting/system_setting.go
+++ b/setting/system_setting.go
@@ -0,0 +1,10 @@
+package setting
+
+var ServerAddress = "http://localhost:3000"
+var WorkerUrl = ""
+var WorkerValidKey = ""
+var WorkerAllowHttpImageRequestEnabled = false
+
+func EnableWorker() bool {
+	return WorkerUrl != ""
+}
--- a/setting/system_setting/oidc.go
+++ b/setting/system_setting/oidc.go
@@ -0,0 +1,25 @@
+package system_setting
+
+import "one-api/setting/config"
+
+type OIDCSettings struct {
+	Enabled               bool   `json:"enabled"`
+	ClientId              string `json:"client_id"`
+	ClientSecret          string `json:"client_secret"`
+	WellKnown             string `json:"well_known"`
+	AuthorizationEndpoint string `json:"authorization_endpoint"`
+	TokenEndpoint         string `json:"token_endpoint"`
+	UserInfoEndpoint      string `json:"user_info_endpoint"`
+}
+
+// 默认配置
+var defaultOIDCSettings = OIDCSettings{}
+
+func init() {
+	// 注册到全局配置管理器
+	config.GlobalConfig.Register("oidc", &defaultOIDCSettings)
+}
+
+func GetOIDCSettings() *OIDCSettings {
+	return &defaultOIDCSettings
+}
--- a/setting/user_usable_group.go
+++ b/setting/user_usable_group.go
@@ -0,0 +1,76 @@
+package setting
+
+import (
+	"encoding/json"
+	"one-api/common"
+	"sync"
+)
+
+var userUsableGroups = map[string]string{
+	"default": "默认分组",
+	"vip":     "vip分组",
+}
+var userUsableGroupsMutex sync.RWMutex
+
+func GetUserUsableGroupsCopy() map[string]string {
+	userUsableGroupsMutex.RLock()
+	defer userUsableGroupsMutex.RUnlock()
+
+	copyUserUsableGroups := make(map[string]string)
+	for k, v := range userUsableGroups {
+		copyUserUsableGroups[k] = v
+	}
+	return copyUserUsableGroups
+}
+
+func UserUsableGroups2JSONString() string {
+	userUsableGroupsMutex.RLock()
+	defer userUsableGroupsMutex.RUnlock()
+
+	jsonBytes, err := json.Marshal(userUsableGroups)
+	if err != nil {
+		common.SysError("error marshalling user groups: " + err.Error())
+	}
+	return string(jsonBytes)
+}
+
+func UpdateUserUsableGroupsByJSONString(jsonStr string) error {
+	userUsableGroupsMutex.Lock()
+	defer userUsableGroupsMutex.Unlock()
+
+	userUsableGroups = make(map[string]string)
+	return json.Unmarshal([]byte(jsonStr), &userUsableGroups)
+}
+
+func GetUserUsableGroups(userGroup string) map[string]string {
+	groupsCopy := GetUserUsableGroupsCopy()
+	if userGroup == "" {
+		if _, ok := groupsCopy["default"]; !ok {
+			groupsCopy["default"] = "default"
+		}
+	}
+	// 如果userGroup不在UserUsableGroups中，返回UserUsableGroups + userGroup
+	if _, ok := groupsCopy[userGroup]; !ok {
+		groupsCopy[userGroup] = "用户分组"
+	}
+	// 如果userGroup在UserUsableGroups中，返回UserUsableGroups
+	return groupsCopy
+}
+
+func GroupInUserUsableGroups(groupName string) bool {
+	userUsableGroupsMutex.RLock()
+	defer userUsableGroupsMutex.RUnlock()
+
+	_, ok := userUsableGroups[groupName]
+	return ok
+}
+
+func GetUsableGroupDescription(groupName string) string {
+	userUsableGroupsMutex.RLock()
+	defer userUsableGroupsMutex.RUnlock()
+
+	if desc, ok := userUsableGroups[groupName]; ok {
+		return desc
+	}
+	return groupName
+}