feat: 调试 suno

feat: suno api 支持
2026-04-04 17:05:35 +00:00 · 2024-06-13 00:32:14 +08:00 · 2024-06-12 20:37:42 +08:00
464 changed files with 18627 additions and 63409 deletions
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,7 +0,0 @@
-.github
-.git
-*.md
-.vscode
-.gitignore
-Makefile
-docs
--- a/.env.example
+++ b/.env.example
@@ -1,67 +0,0 @@
-# 端口号
-# PORT=3000
-# 前端基础URL
-# FRONTEND_BASE_URL=https://your-frontend-url.com
-
-
-# 调试相关配置
-# 启用pprof
-# ENABLE_PPROF=true
-
-# 数据库相关配置
-# 数据库连接字符串
-# SQL_DSN=user:password@tcp(127.0.0.1:3306)/dbname?parseTime=true
-# 日志数据库连接字符串
-# LOG_SQL_DSN=user:password@tcp(127.0.0.1:3306)/logdb?parseTime=true
-# SQLite数据库路径
-# SQLITE_PATH=/path/to/sqlite.db
-# 数据库最大空闲连接数
-# SQL_MAX_IDLE_CONNS=100
-# 数据库最大打开连接数
-# SQL_MAX_OPEN_CONNS=1000
-# 数据库连接最大生命周期（秒）
-# SQL_MAX_LIFETIME=60
-
-
-# 缓存相关配置
-# Redis连接字符串
-# REDIS_CONN_STRING=redis://user:password@localhost:6379/0
-# 同步频率（单位：秒）
-# SYNC_FREQUENCY=60
-# 内存缓存启用
-# MEMORY_CACHE_ENABLED=true
-# 渠道更新频率（单位：秒）
-# CHANNEL_UPDATE_FREQUENCY=30
-# 批量更新启用
-# BATCH_UPDATE_ENABLED=true
-# 批量更新间隔（单位：秒）
-# BATCH_UPDATE_INTERVAL=5
-
-# 任务和功能配置
-# 更新任务启用
-# UPDATE_TASK=true
-
-
-# 会话密钥
-# SESSION_SECRET=random_string
-
-# 其他配置
-# 渠道测试频率（单位：秒）
-# CHANNEL_TEST_FREQUENCY=10
-# 生成默认token
-# GENERATE_DEFAULT_TOKEN=false
-# Cohere 安全设置
-# COHERE_SAFETY_SETTING=NONE
-# 是否统计图片token
-# GET_MEDIA_TOKEN=true
-# 是否在非流（stream=false）情况下统计图片token
-# GET_MEDIA_TOKEN_NOT_STREAM=true
-# 设置 Dify 渠道是否输出工作流和节点信息到客户端
-# DIFY_DEBUG=true
-# 设置流式一次回复的超时时间
-# STREAMING_TIMEOUT=90
-
-
-# 节点类型
-# 如果是主节点则为master
-# NODE_TYPE=master
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -1,12 +0,0 @@
-# These are supported funding model platforms
-
-github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
-patreon: # Replace with a single Patreon username
-open_collective: # Replace with a single Open Collective username
-ko_fi: # Replace with a single Ko-fi username
-tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
-community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
-issuehunt: # Replace with a single IssueHunt username
-otechie: # Replace with a single Otechie username
-custom: ['https://afdian.com/a/new-api'] # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
--- a/.github/workflows/docker-image-amd64.yml
+++ b/.github/workflows/docker-image-amd64.yml
@@ -1,15 +1,14 @@
-name: Publish Docker image (alpha)
+name: Publish Docker image (amd64)

 on:
  push:
-    branches:
-      - alpha
+    tags:
+      - '*'
  workflow_dispatch:
    inputs:
      name:
-        description: "reason"
+        description: 'reason'
        required: false
-
 jobs:
  push_to_registries:
    name: Push Docker image to multiple registries
@@ -19,44 +18,37 @@ jobs:
      contents: read
    steps:
      - name: Check out the repo
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3

      - name: Save version info
        run: |
-          echo "alpha-$(date +'%Y%m%d')-$(git rev-parse --short HEAD)" > VERSION
+          git describe --tags > VERSION 

      - name: Log in to Docker Hub
-        uses: docker/login-action@v3
+        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

      - name: Log in to the Container registry
-        uses: docker/login-action@v3
+        uses: docker/login-action@v2
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
      - name: Extract metadata (tags, labels) for Docker
        id: meta
-        uses: docker/metadata-action@v5
+        uses: docker/metadata-action@v4
        with:
          images: |
            calciumion/new-api
            ghcr.io/${{ github.repository }}
-          tags: |
-            type=raw,value=alpha
-            type=raw,value=alpha-{{date 'YYYYMMDD'}}-{{sha}}

      - name: Build and push Docker images
-        uses: docker/build-push-action@v5
+        uses: docker/build-push-action@v3
        with:
          context: .
-          platforms: linux/amd64,linux/arm64
          push: true
          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
+          labels: ${{ steps.meta.outputs.labels }}
--- a/.github/workflows/docker-image-arm64.yml
+++ b/.github/workflows/docker-image-arm64.yml
@@ -1,9 +1,14 @@
-name: Publish Docker image (Multi Registries)
+name: Publish Docker image (arm64)

 on:
  push:
    tags:
      - '*'
+  workflow_dispatch:
+    inputs:
+      name:
+        description: 'reason'
+        required: false
 jobs:
  push_to_registries:
    name: Push Docker image to multiple registries
@@ -13,26 +18,26 @@ jobs:
      contents: read
    steps:
      - name: Check out the repo
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3

      - name: Save version info
        run: |
          git describe --tags > VERSION 

      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
+        uses: docker/setup-qemu-action@v2

      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v2

      - name: Log in to Docker Hub
-        uses: docker/login-action@v3
+        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

      - name: Log in to the Container registry
-        uses: docker/login-action@v3
+        uses: docker/login-action@v2
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
@@ -40,14 +45,14 @@ jobs:

      - name: Extract metadata (tags, labels) for Docker
        id: meta
-        uses: docker/metadata-action@v5
+        uses: docker/metadata-action@v4
        with:
          images: |
            calciumion/new-api
            ghcr.io/${{ github.repository }}

      - name: Build and push Docker images
-        uses: docker/build-push-action@v5
+        uses: docker/build-push-action@v3
        with:
          context: .
          platforms: linux/amd64,linux/arm64
--- a/.github/workflows/linux-release.yml
+++ b/.github/workflows/linux-release.yml
@@ -3,11 +3,6 @@ permissions:
  contents: write

 on:
-  workflow_dispatch:
-    inputs:
-      name:
-        description: 'reason'
-        required: false
  push:
    tags:
      - '*'
@@ -20,16 +15,16 @@ jobs:
        uses: actions/checkout@v3
        with:
          fetch-depth: 0
-      - uses: oven-sh/setup-bun@v2
+      - uses: actions/setup-node@v3
        with:
-          bun-version: latest
+          node-version: 16
      - name: Build Frontend
        env:
          CI: ""
        run: |
          cd web
-          bun install
-          DISABLE_ESLINT_PLUGIN='true' VITE_REACT_APP_VERSION=$(git describe --tags) bun run build
+          npm install
+          REACT_APP_VERSION=$(git describe --tags) npm run build
          cd ..
      - name: Set up Go
        uses: actions/setup-go@v3
@@ -43,7 +38,7 @@ jobs:
      - name: Build Backend (arm64)
        run: |
          sudo apt-get update
-          DEBIAN_FRONTEND=noninteractive sudo apt-get install -y gcc-aarch64-linux-gnu
+          sudo apt-get install gcc-aarch64-linux-gnu
          CC=aarch64-linux-gnu-gcc CGO_ENABLED=1 GOOS=linux GOARCH=arm64 go build -ldflags "-s -w -X 'one-api/common.Version=$(git describe --tags)' -extldflags '-static'" -o one-api-arm64

      - name: Release
--- a/.github/workflows/macos-release.yml
+++ b/.github/workflows/macos-release.yml
@@ -3,11 +3,6 @@ permissions:
  contents: write

 on:
-  workflow_dispatch:
-    inputs:
-      name:
-        description: 'reason'
-        required: false
  push:
    tags:
      - '*'
@@ -20,16 +15,16 @@ jobs:
        uses: actions/checkout@v3
        with:
          fetch-depth: 0
-      - uses: oven-sh/setup-bun@v2
+      - uses: actions/setup-node@v3
        with:
-          bun-version: latest
+          node-version: 16
      - name: Build Frontend
        env:
          CI: ""
        run: |
          cd web
-          bun install
-          DISABLE_ESLINT_PLUGIN='true' VITE_REACT_APP_VERSION=$(git describe --tags) bun run build
+          npm install
+          REACT_APP_VERSION=$(git describe --tags) npm run build
          cd ..
      - name: Set up Go
        uses: actions/setup-go@v3
--- a/.github/workflows/windows-release.yml
+++ b/.github/workflows/windows-release.yml
@@ -3,11 +3,6 @@ permissions:
  contents: write

 on:
-  workflow_dispatch:
-    inputs:
-      name:
-        description: 'reason'
-        required: false
  push:
    tags:
      - '*'
@@ -23,16 +18,16 @@ jobs:
        uses: actions/checkout@v3
        with:
          fetch-depth: 0
-      - uses: oven-sh/setup-bun@v2
+      - uses: actions/setup-node@v3
        with:
-          bun-version: latest
+          node-version: 16
      - name: Build Frontend
        env:
          CI: ""
        run: |
          cd web
-          bun install
-          DISABLE_ESLINT_PLUGIN='true' VITE_REACT_APP_VERSION=$(git describe --tags) bun run build
+          npm install
+          REACT_APP_VERSION=$(git describe --tags) npm run build
          cd ..
      - name: Set up Go
        uses: actions/setup-go@v3
--- a/.gitignore
+++ b/.gitignore
@@ -5,9 +5,4 @@ upload
 *.db
 build
 *.db-journal
-logs
-web/dist
-.env
-one-api
-.DS_Store
-tiktoken_cache
+logs
--- a/21
+++ b/21
@@ -1,32 +1,31 @@
-FROM oven/bun:latest AS builder
+FROM node:16 as builder

 WORKDIR /build
 COPY web/package.json .
-RUN bun install
+RUN npm install
 COPY ./web .
 COPY ./VERSION .
-RUN DISABLE_ESLINT_PLUGIN='true' VITE_REACT_APP_VERSION=$(cat VERSION) bun run build
+RUN DISABLE_ESLINT_PLUGIN='true' VITE_REACT_APP_VERSION=$(cat VERSION) npm run build

-FROM golang:alpine AS builder2
+FROM golang AS builder2

 ENV GO111MODULE=on \
-    CGO_ENABLED=0 \
+    CGO_ENABLED=1 \
    GOOS=linux

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

 FROM alpine

-RUN apk upgrade --no-cache \
-    && apk add --no-cache ca-certificates tzdata ffmpeg \
-    && update-ca-certificates
+RUN apk update \
+    && apk upgrade \
+    && apk add --no-cache ca-certificates tzdata \
+    && update-ca-certificates 2>/dev/null || true

 COPY --from=builder2 /build/one-api /
 EXPOSE 3000
--- a/docs/models/Midjourney.md
+++ b/docs/models/Midjourney.md
@@ -2,21 +2,6 @@

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

-## 接口列表
-支持的接口如下：
-+ [x] /mj/submit/imagine
-+ [x] /mj/submit/change
-+ [x] /mj/submit/blend
-+ [x] /mj/submit/describe
-+ [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）
-
 ## 模型列表

 ### midjourney-proxy支持
--- a/README.en.md
+++ b/README.en.md
@@ -1,194 +0,0 @@
-<p align="right">
-   <a href="./README.md">中文</a> | <strong>English</strong>
-</p>
-<div align="center">
-
-![new-api](/web/public/logo.png)
-
-# New API
-
-🍥 Next-Generation Large Model Gateway and AI Asset Management System
-
-<a href="https://trendshift.io/repositories/8227" target="_blank"><img src="https://trendshift.io/api/badge/repositories/8227" alt="Calcium-Ion%2Fnew-api | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
-
-<p align="center">
-  <a href="https://raw.githubusercontent.com/Calcium-Ion/new-api/main/LICENSE">
-    <img src="https://img.shields.io/github/license/Calcium-Ion/new-api?color=brightgreen" alt="license">
-  </a>
-  <a href="https://github.com/Calcium-Ion/new-api/releases/latest">
-    <img src="https://img.shields.io/github/v/release/Calcium-Ion/new-api?color=brightgreen&include_prereleases" alt="release">
-  </a>
-  <a href="https://github.com/users/Calcium-Ion/packages/container/package/new-api">
-    <img src="https://img.shields.io/badge/docker-ghcr.io-blue" alt="docker">
-  </a>
-  <a href="https://hub.docker.com/r/CalciumIon/new-api">
-    <img src="https://img.shields.io/badge/docker-dockerHub-blue" alt="docker">
-  </a>
-  <a href="https://goreportcard.com/report/github.com/Calcium-Ion/new-api">
-    <img src="https://goreportcard.com/badge/github.com/Calcium-Ion/new-api" alt="GoReportCard">
-  </a>
-</p>
-</div>
-
-## 📝 Project Description
-
-> [!NOTE]  
-> This is an open-source project developed based on [One API](https://github.com/songquanpeng/one-api)
-
-> [!IMPORTANT]  
-> - This project is for personal learning purposes only, with no guarantee of stability or technical support.
-> - Users must comply with OpenAI's [Terms of Use](https://openai.com/policies/terms-of-use) and **applicable laws and regulations**, and must not use it for illegal purposes.
-> - According to the [《Interim Measures for the Management of Generative Artificial Intelligence Services》](http://www.cac.gov.cn/2023-07/13/c_1690898327029107.htm), please do not provide any unregistered generative AI services to the public in China.
-
-## 📚 Documentation
-
-For detailed documentation, please visit our official Wiki: [https://docs.newapi.pro/](https://docs.newapi.pro/)
-
-You can also access the AI-generated DeepWiki:
-[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/QuantumNous/new-api)
-
-## ✨ Key Features
-
-New API offers a wide range of features, please refer to [Features Introduction](https://docs.newapi.pro/wiki/features-introduction) for details:
-
-1. 🎨 Brand new UI interface
-2. 🌍 Multi-language support
-3. 💰 Online recharge functionality (YiPay)
-4. 🔍 Support for querying usage quotas with keys (works with [neko-api-key-tool](https://github.com/Calcium-Ion/neko-api-key-tool))
-5. 🔄 Compatible with the original One API database
-6. 💵 Support for pay-per-use model pricing
-7. ⚖️ Support for weighted random channel selection
-8. 📈 Data dashboard (console)
-9. 🔒 Token grouping and model restrictions
-10. 🤖 Support for more authorization login methods (LinuxDO, Telegram, OIDC)
-11. 🔄 Support for Rerank models (Cohere and Jina), [API Documentation](https://docs.newapi.pro/api/jinaai-rerank)
-12. ⚡ Support for OpenAI Realtime API (including Azure channels), [API Documentation](https://docs.newapi.pro/api/openai-realtime)
-13. ⚡ Support for Claude Messages format, [API Documentation](https://docs.newapi.pro/api/anthropic-chat)
-14. Support for entering chat interface via /chat2link route
-15. 🧠 Support for setting reasoning effort through model name suffixes:
-    1. OpenAI o-series models
-        - Add `-high` suffix for high reasoning effort (e.g.: `o3-mini-high`)
-        - Add `-medium` suffix for medium reasoning effort (e.g.: `o3-mini-medium`)
-        - Add `-low` suffix for low reasoning effort (e.g.: `o3-mini-low`)
-    2. Claude thinking models
-        - Add `-thinking` suffix to enable thinking mode (e.g.: `claude-3-7-sonnet-20250219-thinking`)
-16. 🔄 Thinking-to-content functionality
-17. 🔄 Model rate limiting for users
-18. 💰 Cache billing support, which allows billing at a set ratio when cache is hit:
-    1. Set the `Prompt Cache Ratio` option in `System Settings-Operation Settings`
-    2. Set `Prompt Cache Ratio` in the channel, range 0-1, e.g., setting to 0.5 means billing at 50% when cache is hit
-    3. Supported channels:
-        - [x] OpenAI
-        - [x] Azure
-        - [x] DeepSeek
-        - [x] Claude
-
-## Model Support
-
-This version supports multiple models, please refer to [API Documentation-Relay Interface](https://docs.newapi.pro/api) for details:
-
-1. Third-party models **gpts** (gpt-4-gizmo-*)
-2. Third-party channel [Midjourney-Proxy(Plus)](https://github.com/novicezk/midjourney-proxy) interface, [API Documentation](https://docs.newapi.pro/api/midjourney-proxy-image)
-3. Third-party channel [Suno API](https://github.com/Suno-API/Suno-API) interface, [API Documentation](https://docs.newapi.pro/api/suno-music)
-4. Custom channels, supporting full call address input
-5. Rerank models ([Cohere](https://cohere.ai/) and [Jina](https://jina.ai/)), [API Documentation](https://docs.newapi.pro/api/jinaai-rerank)
-6. Claude Messages format, [API Documentation](https://docs.newapi.pro/api/anthropic-chat)
-7. Dify, currently only supports chatflow
-
-## Environment Variable Configuration
-
-For detailed configuration instructions, please refer to [Installation Guide-Environment Variables Configuration](https://docs.newapi.pro/installation/environment-variables):
-
- `GENERATE_DEFAULT_TOKEN`: Whether to generate initial tokens for newly registered users, default is `false`
- `STREAMING_TIMEOUT`: Streaming response timeout, default is 60 seconds
- `DIFY_DEBUG`: Whether to output workflow and node information for Dify channels, default is `true`
- `FORCE_STREAM_OPTION`: Whether to override client stream_options parameter, default is `true`
- `GET_MEDIA_TOKEN`: Whether to count image tokens, default is `true`
- `GET_MEDIA_TOKEN_NOT_STREAM`: Whether to count image tokens in non-streaming cases, default is `true`
- `UPDATE_TASK`: Whether to update asynchronous tasks (Midjourney, Suno), default is `true`
- `COHERE_SAFETY_SETTING`: Cohere model safety settings, options are `NONE`, `CONTEXTUAL`, `STRICT`, default is `NONE`
- `GEMINI_VISION_MAX_IMAGE_NUM`: Maximum number of images for Gemini models, default is `16`
- `MAX_FILE_DOWNLOAD_MB`: Maximum file download size in MB, default is `20`
- `CRYPTO_SECRET`: Encryption key used for encrypting database content
- `AZURE_DEFAULT_API_VERSION`: Azure channel default API version, default is `2025-04-01-preview`
- `NOTIFICATION_LIMIT_DURATION_MINUTE`: Notification limit duration, default is `10` minutes
- `NOTIFY_LIMIT_COUNT`: Maximum number of user notifications within the specified duration, default is `2`
- `ERROR_LOG_ENABLED=true`: Whether to record and display error logs, default is `false`
-
-## Deployment
-
-For detailed deployment guides, please refer to [Installation Guide-Deployment Methods](https://docs.newapi.pro/installation):
-
-> [!TIP]
-> Latest Docker image: `calciumion/new-api:latest`
-
-### Multi-machine Deployment Considerations
- Environment variable `SESSION_SECRET` must be set, otherwise login status will be inconsistent across multiple machines
- If sharing Redis, `CRYPTO_SECRET` must be set, otherwise Redis content cannot be accessed across multiple machines
-
-### Deployment Requirements
- Local database (default): SQLite (Docker deployment must mount the `/data` directory)
- Remote database: MySQL version >= 5.7.8, PgSQL version >= 9.6
-
-### Deployment Methods
-
-#### Using BaoTa Panel Docker Feature
-Install BaoTa Panel (version **9.2.0** or above), find **New-API** in the application store and install it.
-[Tutorial with images](./docs/BT.md)
-
-#### Using Docker Compose (Recommended)
-```shell
-# Download the project
-git clone https://github.com/Calcium-Ion/new-api.git
-cd new-api
-# Edit docker-compose.yml as needed
-# Start
-docker-compose up -d
-```
-
-#### Using Docker Image Directly
-```shell
-# Using SQLite
-docker run --name new-api -d --restart always -p 3000:3000 -e TZ=Asia/Shanghai -v /home/ubuntu/data/new-api:/data calciumion/new-api:latest
-
-# Using MySQL
-docker run --name new-api -d --restart always -p 3000:3000 -e SQL_DSN="root:123456@tcp(localhost:3306)/oneapi" -e TZ=Asia/Shanghai -v /home/ubuntu/data/new-api:/data calciumion/new-api:latest
-```
-
-## Channel Retry and Cache
-Channel retry functionality has been implemented, you can set the number of retries in `Settings->Operation Settings->General Settings`. It is **recommended to enable caching**.
-
-### Cache Configuration Method
-1. `REDIS_CONN_STRING`: Set Redis as cache
-2. `MEMORY_CACHE_ENABLED`: Enable memory cache (no need to set manually if Redis is set)
-
-## API Documentation
-
-For detailed API documentation, please refer to [API Documentation](https://docs.newapi.pro/api):
-
- [Chat API](https://docs.newapi.pro/api/openai-chat)
- [Image API](https://docs.newapi.pro/api/openai-image)
- [Rerank API](https://docs.newapi.pro/api/jinaai-rerank)
- [Realtime API](https://docs.newapi.pro/api/openai-realtime)
- [Claude Chat API (messages)](https://docs.newapi.pro/api/anthropic-chat)
-
-## Related Projects
- [One API](https://github.com/songquanpeng/one-api): Original project
- [Midjourney-Proxy](https://github.com/novicezk/midjourney-proxy): Midjourney interface support
- [chatnio](https://github.com/Deeptrain-Community/chatnio): Next-generation AI one-stop B/C-end solution
- [neko-api-key-tool](https://github.com/Calcium-Ion/neko-api-key-tool): Query usage quota with key
-
-Other projects based on New API:
- [new-api-horizon](https://github.com/Calcium-Ion/new-api-horizon): High-performance optimized version of New API
- [VoAPI](https://github.com/VoAPI/VoAPI): Frontend beautified version based on New API
-
-## Help and Support
-
-If you have any questions, please refer to [Help and Support](https://docs.newapi.pro/support):
- [Community Interaction](https://docs.newapi.pro/support/community-interaction)
- [Issue Feedback](https://docs.newapi.pro/support/feedback-issues)
- [FAQ](https://docs.newapi.pro/support/faq)
-
-## 🌟 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/README.md
+++ b/README.md
@@ -1,196 +1,134 @@
-<p align="right">
-   <strong>中文</strong> | <a href="./README.en.md">English</a>
-</p>
-<div align="center">
-
-![new-api](/web/public/logo.png)

 # New API

-🍥新一代大模型网关与AI资产管理系统
+> [!NOTE]
+> 本项目为开源项目，在[One API](https://github.com/songquanpeng/one-api)的基础上进行二次开发，感谢原作者的无私奉献。 
+> 使用者必须在遵循 OpenAI 的[使用条款](https://openai.com/policies/terms-of-use)以及**法律法规**的情况下使用，不得用于非法用途。

-<a href="https://trendshift.io/repositories/8227" target="_blank"><img src="https://trendshift.io/api/badge/repositories/8227" alt="Calcium-Ion%2Fnew-api | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>

-<p align="center">
-  <a href="https://raw.githubusercontent.com/Calcium-Ion/new-api/main/LICENSE">
-    <img src="https://img.shields.io/github/license/Calcium-Ion/new-api?color=brightgreen" alt="license">
-  </a>
-  <a href="https://github.com/Calcium-Ion/new-api/releases/latest">
-    <img src="https://img.shields.io/github/v/release/Calcium-Ion/new-api?color=brightgreen&include_prereleases" alt="release">
-  </a>
-  <a href="https://github.com/users/Calcium-Ion/packages/container/package/new-api">
-    <img src="https://img.shields.io/badge/docker-ghcr.io-blue" alt="docker">
-  </a>
-  <a href="https://hub.docker.com/r/CalciumIon/new-api">
-    <img src="https://img.shields.io/badge/docker-dockerHub-blue" alt="docker">
-  </a>
-  <a href="https://goreportcard.com/report/github.com/Calcium-Ion/new-api">
-    <img src="https://goreportcard.com/badge/github.com/Calcium-Ion/new-api" alt="GoReportCard">
-  </a>
-  <a href="https://coderabbit.ai">
-    <img src="https://img.shields.io/coderabbit/prs/github/QuantumNous/new-api?utm_source=oss&utm_medium=github&utm_campaign=QuantumNous%2Fnew-api&labelColor=171717&color=FF570A&link=https%3A%2F%2Fcoderabbit.ai&label=CodeRabbit+Reviews" alt="CodeRabbit Pull Request Reviews">
-  </a>
-</p>
-</div>
+> [!WARNING]
+> 本项目为个人学习使用，不保证稳定性，且不提供任何技术支持，使用者必须在遵循 OpenAI 的使用条款以及法律法规的情况下使用，不得用于非法用途。  
+> 根据[《生成式人工智能服务管理暂行办法》](http://www.cac.gov.cn/2023-07/13/c_1690898327029107.htm)的要求，请勿对中国地区公众提供一切未经备案的生成式人工智能服务。

-## 📝 项目说明
+> [!NOTE]
+> 最新版Docker镜像 calciumion/new-api:latest  
+> 更新指令 docker run --rm -v /var/run/docker.sock:/var/run/docker.sock containrrr/watchtower -cR

-> [!NOTE]  
-> 本项目为开源项目，在[One API](https://github.com/songquanpeng/one-api)的基础上进行二次开发
+## 主要变更
+此分叉版本的主要变更如下：

-> [!IMPORTANT]  
-> - 本项目仅供个人学习使用，不保证稳定性，且不提供任何技术支持。
-> - 使用者必须在遵循 OpenAI 的[使用条款](https://openai.com/policies/terms-of-use)以及**法律法规**的情况下使用，不得用于非法用途。
-> - 根据[《生成式人工智能服务管理暂行办法》](http://www.cac.gov.cn/2023-07/13/c_1690898327029107.htm)的要求，请勿对中国地区公众提供一切未经备案的生成式人工智能服务。
-
-## 📚 文档
-
-详细文档请访问我们的官方Wiki：[https://docs.newapi.pro/](https://docs.newapi.pro/)
-
-也可访问AI生成的DeepWiki:
-[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/QuantumNous/new-api)
-
-## ✨ 主要特性
-
-New API提供了丰富的功能，详细特性请参考[特性说明](https://docs.newapi.pro/wiki/features-introduction)：
-
-1. 🎨 全新的UI界面
-2. 🌍 多语言支持
-3. 💰 支持在线充值功能（易支付）
-4. 🔍 支持用key查询使用额度（配合[neko-api-key-tool](https://github.com/Calcium-Ion/neko-api-key-tool)）
-5. 🔄 兼容原版One API的数据库
-6. 💵 支持模型按次数收费
-7. ⚖️ 支持渠道加权随机
-8. 📈 数据看板（控制台）
-9. 🔒 令牌分组、模型限制
-10. 🤖 支持更多授权登陆方式（LinuxDO,Telegram、OIDC）
-11. 🔄 支持Rerank模型（Cohere和Jina），[接口文档](https://docs.newapi.pro/api/jinaai-rerank)
-12. ⚡ 支持OpenAI Realtime API（包括Azure渠道），[接口文档](https://docs.newapi.pro/api/openai-realtime)
-13. ⚡ 支持Claude Messages 格式，[接口文档](https://docs.newapi.pro/api/anthropic-chat)
-14. 支持使用路由/chat2link进入聊天界面
-15. 🧠 支持通过模型名称后缀设置 reasoning effort：
-    1. OpenAI o系列模型
-        - 添加后缀 `-high` 设置为 high reasoning effort (例如: `o3-mini-high`)
-        - 添加后缀 `-medium` 设置为 medium reasoning effort (例如: `o3-mini-medium`)
-        - 添加后缀 `-low` 设置为 low reasoning effort (例如: `o3-mini-low`)
-    2. Claude 思考模型
-        - 添加后缀 `-thinking` 启用思考模式 (例如: `claude-3-7-sonnet-20250219-thinking`)
-16. 🔄 思考转内容功能
-17. 🔄 针对用户的模型限流功能
-18. 💰 缓存计费支持，开启后可以在缓存命中时按照设定的比例计费：
-    1. 在 `系统设置-运营设置` 中设置 `提示缓存倍率` 选项
-    2. 在渠道中设置 `提示缓存倍率`，范围 0-1，例如设置为 0.5 表示缓存命中时按照 50% 计费
-    3. 支持的渠道：
-        - [x] OpenAI
-        - [x] Azure
-        - [x] DeepSeek
-        - [x] Claude
+1. 全新的UI界面（部分界面还待更新）
+2. 添加[Midjourney-Proxy(Plus)](https://github.com/novicezk/midjourney-proxy)接口的支持，[对接文档](Midjourney.md)，支持的接口如下：
+   + [x] /mj/submit/imagine
+   + [x] /mj/submit/change
+   + [x] /mj/submit/blend
+   + [x] /mj/submit/describe
+   + [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查询使用额度:
+   + 配合项目[neko-api-key-tool](https://github.com/Calcium-Ion/neko-api-key-tool)可实现用key查询使用
+5. 渠道显示已使用额度，支持指定组织访问
+6. 分页支持选择每页显示数量
+7. 兼容原版One API的数据库，可直接使用原版数据库（one-api.db）
+8. 支持模型按次数收费，可在 系统设置-运营设置 中设置
+9. 支持渠道**加权随机**
+10. 数据看板
+11. 可设置令牌能调用的模型
+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/)
+7. 自定义渠道，支持填入完整调用地址

-此版本支持多种模型，详情请参考[接口文档-中继接口](https://docs.newapi.pro/api)：
+您可以在渠道中添加自定义模型gpt-4-gizmo-*，此模型并非OpenAI官方模型，而是第三方模型，使用官方key无法调用。

-1. 第三方模型 **gpts** （gpt-4-gizmo-*）
-2. 第三方渠道[Midjourney-Proxy(Plus)](https://github.com/novicezk/midjourney-proxy)接口，[接口文档](https://docs.newapi.pro/api/midjourney-proxy-image)
-3. 第三方渠道[Suno API](https://github.com/Suno-API/Suno-API)接口，[接口文档](https://docs.newapi.pro/api/suno-music)
-4. 自定义渠道，支持填入完整调用地址
-5. Rerank模型（[Cohere](https://cohere.ai/)和[Jina](https://jina.ai/)），[接口文档](https://docs.newapi.pro/api/jinaai-rerank)
-6. Claude Messages 格式，[接口文档](https://docs.newapi.pro/api/anthropic-chat)
-7. Dify，当前仅支持chatflow
+## 渠道重试
+渠道重试功能已经实现，可以在`设置->运营设置->通用设置`设置重试次数，**建议开启缓存**功能。  
+如果开启了重试功能，第一次重试使用同优先级，第二次重试使用下一个优先级，以此类推。  
+### 缓存设置方法
+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`
+### 为什么有的时候没有重试
+这些错误码不会重试：400，504，524
+### 我想让400也重试
+在`渠道->编辑`中，将`状态码复写`改为
+```json
+{
+  "400": "500"
+}
+```
+可以实现400错误转为500错误，从而重试

-## 环境变量配置
-
-详细配置说明请参考[安装指南-环境变量配置](https://docs.newapi.pro/installation/environment-variables)：
-
- `GENERATE_DEFAULT_TOKEN`：是否为新注册用户生成初始令牌，默认为 `false`
- `STREAMING_TIMEOUT`：流式回复超时时间，默认60秒
- `DIFY_DEBUG`：Dify渠道是否输出工作流和节点信息，默认 `true`
- `FORCE_STREAM_OPTION`：是否覆盖客户端stream_options参数，默认 `true`
- `GET_MEDIA_TOKEN`：是否统计图片token，默认 `true`
- `GET_MEDIA_TOKEN_NOT_STREAM`：非流情况下是否统计图片token，默认 `true`
- `UPDATE_TASK`：是否更新异步任务（Midjourney、Suno），默认 `true`
- `COHERE_SAFETY_SETTING`：Cohere模型安全设置，可选值为 `NONE`, `CONTEXTUAL`, `STRICT`，默认 `NONE`
- `GEMINI_VISION_MAX_IMAGE_NUM`：Gemini模型最大图片数量，默认 `16`
- `MAX_FILE_DOWNLOAD_MB`: 最大文件下载大小，单位MB，默认 `20`
- `CRYPTO_SECRET`：加密密钥，用于加密数据库内容
- `AZURE_DEFAULT_API_VERSION`：Azure渠道默认API版本，默认 `2025-04-01-preview`
- `NOTIFICATION_LIMIT_DURATION_MINUTE`：通知限制持续时间，默认 `10`分钟
- `NOTIFY_LIMIT_COUNT`：用户通知在指定持续时间内的最大数量，默认 `2`
- `ERROR_LOG_ENABLED=true`: 是否记录并显示错误日志，默认`false`

 ## 部署
-
-详细部署指南请参考[安装指南-部署方式](https://docs.newapi.pro/installation)：
-
-> [!TIP]
-> 最新版Docker镜像：`calciumion/new-api:latest`  
-
-### 多机部署注意事项
- 必须设置环境变量 `SESSION_SECRET`，否则会导致多机部署时登录状态不一致
- 如果公用Redis，必须设置 `CRYPTO_SECRET`，否则会导致多机部署时Redis内容无法获取
-
-### 部署要求
- 本地数据库（默认）：SQLite（Docker部署必须挂载`/data`目录）
- 远程数据库：MySQL版本 >= 5.7.8，PgSQL版本 >= 9.6
-
-### 部署方式
-
-#### 使用宝塔面板Docker功能部署
-安装宝塔面板（**9.2.0版本**及以上），在应用商店中找到**New-API**安装即可。
-[图文教程](./docs/BT.md)
-
-#### 使用Docker Compose部署（推荐）
+### 基于 Docker 进行部署
 ```shell
-# 下载项目
-git clone https://github.com/Calcium-Ion/new-api.git
-cd new-api
-# 按需编辑docker-compose.yml
-# 启动
-docker-compose up -d
-```
-
-#### 直接使用Docker镜像
-```shell
-# 使用SQLite
+# 使用 SQLite 的部署命令：
 docker run --name new-api -d --restart always -p 3000:3000 -e TZ=Asia/Shanghai -v /home/ubuntu/data/new-api:/data calciumion/new-api:latest
-
-# 使用MySQL
+# 使用 MySQL 的部署命令，在上面的基础上添加 `-e SQL_DSN="root:123456@tcp(localhost:3306)/oneapi"`，请自行修改数据库连接参数。
+# 例如：
 docker run --name new-api -d --restart always -p 3000:3000 -e SQL_DSN="root:123456@tcp(localhost:3306)/oneapi" -e TZ=Asia/Shanghai -v /home/ubuntu/data/new-api:/data calciumion/new-api:latest
 ```
+### 使用宝塔面板Docker功能部署
+```shell
+# 使用 SQLite 的部署命令：
+docker run --name new-api -d --restart always -p 3000:3000 -e TZ=Asia/Shanghai -v /www/wwwroot/new-api:/data calciumion/new-api:latest
+# 使用 MySQL 的部署命令，在上面的基础上添加 `-e SQL_DSN="root:123456@tcp(localhost:3306)/oneapi"`，请自行修改数据库连接参数。
+# 例如：
+# 注意：数据库要开启远程访问，并且只允许服务器IP访问
+docker run --name new-api -d --restart always -p 3000:3000 -e SQL_DSN="root:123456@tcp(宝塔的服务器地址:宝塔数据库端口)/宝塔数据库名称" -e TZ=Asia/Shanghai -v /www/wwwroot/new-api:/data calciumion/new-api:latest
+# 注意：数据库要开启远程访问，并且只允许服务器IP访问
+```
+### 默认账号密码
+默认账号root 密码123456

-## 渠道重试与缓存
-渠道重试功能已经实现，可以在`设置->运营设置->通用设置`设置重试次数，**建议开启缓存**功能。
+## Midjourney接口设置文档
+[对接文档](Midjourney.md)

-### 缓存设置方法
-1. `REDIS_CONN_STRING`：设置Redis作为缓存
-2. `MEMORY_CACHE_ENABLED`：启用内存缓存（设置了Redis则无需手动设置）
+## 交流群
+<img src="https://github.com/Calcium-Ion/new-api/assets/61247483/de536a8a-0161-47a7-a0a2-66ef6de81266" width="300">

-## 接口文档
+## 界面截图
+![image](https://github.com/Calcium-Ion/new-api/assets/61247483/ad0e7aae-0203-471c-9716-2d83768927d4)

-详细接口文档请参考[接口文档](https://docs.newapi.pro/api)：
+![image](https://github.com/Calcium-Ion/new-api/assets/61247483/d1ac216e-0804-4105-9fdc-66b35022d861)

- [聊天接口（Chat）](https://docs.newapi.pro/api/openai-chat)
- [图像接口（Image）](https://docs.newapi.pro/api/openai-image)
- [重排序接口（Rerank）](https://docs.newapi.pro/api/jinaai-rerank)
- [实时对话接口（Realtime）](https://docs.newapi.pro/api/openai-realtime)
- [Claude聊天接口（messages）](https://docs.newapi.pro/api/anthropic-chat)
+![image](https://github.com/Calcium-Ion/new-api/assets/61247483/3ca0b282-00ff-4c96-bf9d-e29ef615c605)  
+![image](https://github.com/Calcium-Ion/new-api/assets/61247483/f4f40ed4-8ccb-43d7-a580-90677827646d)  
+![image](https://github.com/Calcium-Ion/new-api/assets/61247483/90d7d763-6a77-4b36-9f76-2bb30f18583d)
+![image](https://github.com/Calcium-Ion/new-api/assets/61247483/e414228a-3c35-429a-b298-6451d76d9032)
+夜间模式  
+![image](https://github.com/Calcium-Ion/new-api/assets/61247483/1c66b593-bb9e-4757-9720-ff2759539242)
+
+![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端解决方案
+- [chatnio](https://github.com/Deeptrain-Community/chatnio)：下一代 AI 一站式 B/C 端解决方案
 - [neko-api-key-tool](https://github.com/Calcium-Ion/neko-api-key-tool)：用key查询使用额度

-其他基于New API的项目：
- [new-api-horizon](https://github.com/Calcium-Ion/new-api-horizon)：New API高性能优化版
-
-## 帮助支持
-
-如有问题，请参考[帮助支持](https://docs.newapi.pro/support)：
- [社区交流](https://docs.newapi.pro/support/community-interaction)
- [反馈问题](https://docs.newapi.pro/support/feedback-issues)
- [常见问题](https://docs.newapi.pro/support/faq)
-
-## 🌟 Star History
+## 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
@@ -1,8 +1,8 @@
 package common

 import (
-	//"os"
-	//"strconv"
+	"os"
+	"strconv"
 	"sync"
 	"time"

@@ -15,9 +15,8 @@ var SystemName = "New API"
 var Footer = ""
 var Logo = ""
 var TopUpLink = ""
-
-// var ChatLink = ""
-// var ChatLink2 = ""
+var ChatLink = ""
+var ChatLink2 = ""
 var QuotaPerUnit = 500 * 1000.0 // $0.002 / 1K tokens
 var DisplayInCurrencyEnabled = true
 var DisplayTokenStatEnabled = true
@@ -31,7 +30,6 @@ var DefaultCollapseSidebar = false // default value of collapse sidebar
 // Any options with "Secret", "Token" in its key won't be return by GetOptions

 var SessionSecret = uuid.New().String()
-var CryptoSecret = uuid.New().String()

 var OptionMap map[string]string
 var OptionMapRWMutex sync.RWMutex
@@ -43,7 +41,6 @@ var PasswordLoginEnabled = true
 var PasswordRegisterEnabled = true
 var EmailVerificationEnabled = false
 var GitHubOAuthEnabled = false
-var LinuxDOOAuthEnabled = false
 var WeChatAuthEnabled = false
 var TelegramOAuthEnabled = false
 var TurnstileCheckEnabled = false
@@ -62,13 +59,9 @@ var EmailDomainWhitelist = []string{
 	"yahoo.com",
 	"foxmail.com",
 }
-var EmailLoginAuthServerList = []string{
-	"smtp.sendcloud.net",
-	"smtp.azurecomm.net",
-}

-var DebugEnabled bool
-var MemoryCacheEnabled bool
+var DebugEnabled = os.Getenv("DEBUG") == "true"
+var MemoryCacheEnabled = os.Getenv("MEMORY_CACHE_ENABLED") == "true"

 var LogConsumeEnabled = true

@@ -81,8 +74,6 @@ var SMTPToken = ""

 var GitHubClientId = ""
 var GitHubClientSecret = ""
-var LinuxDOClientId = ""
-var LinuxDOClientSecret = ""

 var WeChatServerAddress = ""
 var WeChatServerToken = ""
@@ -105,24 +96,21 @@ var PreConsumedQuota = 500

 var RetryTimes = 0

-//var RootUserEmail = ""
+var RootUserEmail = ""

-var IsMasterNode bool
+var IsMasterNode = os.Getenv("NODE_TYPE") != "slave"

-var requestInterval int
-var RequestInterval time.Duration
+var requestInterval, _ = strconv.Atoi(os.Getenv("POLLING_INTERVAL"))
+var RequestInterval = time.Duration(requestInterval) * time.Second

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

 var BatchUpdateEnabled = false
-var BatchUpdateInterval int
+var BatchUpdateInterval = GetOrDefault("BATCH_UPDATE_INTERVAL", 5)

-var RelayTimeout int // unit is second
+var RelayTimeout = GetOrDefault("RELAY_TIMEOUT", 0) // unit is second

-var GeminiSafetySetting string
-
-// https://docs.cohere.com/docs/safety-modes Type; NONE/CONTEXTUAL/STRICT
-var CohereSafetySetting string
+var GeminiSafetySetting = GetOrDefaultString("GEMINI_SAFETY_SETTING", "BLOCK_NONE")

 const (
 	RequestIdKey = "X-Oneapi-Request-Id"
@@ -135,10 +123,6 @@ const (
 	RoleRootUser   = 100
 )

-func IsValidateRole(role int) bool {
-	return role == RoleGuestUser || role == RoleCommonUser || role == RoleAdminUser || role == RoleRootUser
-}
-
 var (
 	FileUploadPermission    = RoleGuestUser
 	FileDownloadPermission  = RoleGuestUser
@@ -149,13 +133,11 @@ var (
 // All duration's unit is seconds
 // Shouldn't larger then RateLimitKeyExpirationDuration
 var (
-	GlobalApiRateLimitEnable   bool
-	GlobalApiRateLimitNum      int
-	GlobalApiRateLimitDuration int64
+	GlobalApiRateLimitNum            = GetOrDefault("GLOBAL_API_RATE_LIMIT", 180)
+	GlobalApiRateLimitDuration int64 = 3 * 60

-	GlobalWebRateLimitEnable   bool
-	GlobalWebRateLimitNum      int
-	GlobalWebRateLimitDuration int64
+	GlobalWebRateLimitNum            = GetOrDefault("GLOBAL_WEB_RATE_LIMIT", 60)
+	GlobalWebRateLimitDuration int64 = 3 * 60

 	UploadRateLimitNum            = 10
 	UploadRateLimitDuration int64 = 60
@@ -228,49 +210,36 @@ const (
 	ChannelTypeCohere         = 34
 	ChannelTypeMiniMax        = 35
 	ChannelTypeSunoAPI        = 36
-	ChannelTypeDify           = 37
-	ChannelTypeJina           = 38
-	ChannelCloudflare         = 39
-	ChannelTypeSiliconFlow    = 40
-	ChannelTypeVertexAi       = 41
-	ChannelTypeMistral        = 42
-	ChannelTypeDeepSeek       = 43
-	ChannelTypeMokaAI         = 44
-	ChannelTypeVolcEngine     = 45
-	ChannelTypeBaiduV2        = 46
-	ChannelTypeXinference     = 47
-	ChannelTypeXai            = 48
-	ChannelTypeCoze           = 49
-	ChannelTypeKling          = 50
-	ChannelTypeDummy          // this one is only for count, do not add any channel after this
+
+	ChannelTypeDummy // this one is only for count, do not add any channel after this

 )

 var ChannelBaseURLs = []string{
-	"",                                    // 0
-	"https://api.openai.com",              // 1
-	"https://oa.api2d.net",                // 2
-	"",                                    // 3
-	"http://localhost:11434",              // 4
-	"https://api.openai-sb.com",           // 5
-	"https://api.openaimax.com",           // 6
-	"https://api.ohmygpt.com",             // 7
-	"",                                    // 8
-	"https://api.caipacity.com",           // 9
-	"https://api.aiproxy.io",              // 10
-	"",                                    // 11
-	"https://api.api2gpt.com",             // 12
-	"https://api.aigc2d.com",              // 13
-	"https://api.anthropic.com",           // 14
-	"https://aip.baidubce.com",            // 15
-	"https://open.bigmodel.cn",            // 16
-	"https://dashscope.aliyuncs.com",      // 17
-	"",                                    // 18
-	"https://api.360.cn",                  // 19
-	"https://openrouter.ai/api",           // 20
-	"https://api.aiproxy.io",              // 21
-	"https://fastgpt.run/api/openapi",     // 22
-	"https://hunyuan.tencentcloudapi.com", //23
+	"",                                  // 0
+	"https://api.openai.com",            // 1
+	"https://oa.api2d.net",              // 2
+	"",                                  // 3
+	"http://localhost:11434",            // 4
+	"https://api.openai-sb.com",         // 5
+	"https://api.openaimax.com",         // 6
+	"https://api.ohmygpt.com",           // 7
+	"",                                  // 8
+	"https://api.caipacity.com",         // 9
+	"https://api.aiproxy.io",            // 10
+	"",                                  // 11
+	"https://api.api2gpt.com",           // 12
+	"https://api.aigc2d.com",            // 13
+	"https://api.anthropic.com",         // 14
+	"https://aip.baidubce.com",          // 15
+	"https://open.bigmodel.cn",          // 16
+	"https://dashscope.aliyuncs.com",    // 17
+	"",                                  // 18
+	"https://ai.360.cn",                 // 19
+	"https://openrouter.ai/api",         // 20
+	"https://api.aiproxy.io",            // 21
+	"https://fastgpt.run/api/openapi",   // 22
+	"https://hunyuan.cloud.tencent.com", //23
 	"https://generativelanguage.googleapis.com", //24
 	"https://api.moonshot.cn",                   //25
 	"https://open.bigmodel.cn",                  //26
@@ -284,18 +253,4 @@ var ChannelBaseURLs = []string{
 	"https://api.cohere.ai",                     //34
 	"https://api.minimax.chat",                  //35
 	"",                                          //36
-	"https://api.dify.ai",                       //37
-	"https://api.jina.ai",                       //38
-	"https://api.cloudflare.com",                //39
-	"https://api.siliconflow.cn",                //40
-	"",                                          //41
-	"https://api.mistral.ai",                    //42
-	"https://api.deepseek.com",                  //43
-	"https://api.moka.ai",                       //44
-	"https://ark.cn-beijing.volces.com",         //45
-	"https://qianfan.baidubce.com",              //46
-	"",                                          //47
-	"https://api.x.ai",                          //48
-	"https://api.coze.cn",                       //49
-	"https://api.klingai.com",                   //50
 }
--- a/common/crypto.go
+++ b/common/crypto.go
@@ -1,23 +1,6 @@
 package common

-import (
-	"crypto/hmac"
-	"crypto/sha256"
-	"encoding/hex"
-	"golang.org/x/crypto/bcrypt"
-)
-
-func GenerateHMACWithKey(key []byte, data string) string {
-	h := hmac.New(sha256.New, key)
-	h.Write([]byte(data))
-	return hex.EncodeToString(h.Sum(nil))
-}
-
-func GenerateHMAC(data string) string {
-	h := hmac.New(sha256.New, []byte(CryptoSecret))
-	h.Write([]byte(data))
-	return hex.EncodeToString(h.Sum(nil))
-}
+import "golang.org/x/crypto/bcrypt"

 func Password2Hash(password string) (string, error) {
 	passwordBytes := []byte(password)
--- a/common/custom-event.go
+++ b/common/custom-event.go
@@ -44,7 +44,7 @@ var fieldReplacer = strings.NewReplacer(
 	"\r", "\\r")

 var dataReplacer = strings.NewReplacer(
-	"\n", "\n",
+	"\n", "\ndata:",
 	"\r", "\\r")

 type CustomEvent struct {
--- a/common/database.go
+++ b/common/database.go
@@ -1,15 +1,7 @@
 package common

-const (
-	DatabaseTypeMySQL      = "mysql"
-	DatabaseTypeSQLite     = "sqlite"
-	DatabaseTypePostgreSQL = "postgres"
-)
-
 var UsingSQLite = false
 var UsingPostgreSQL = false
-var LogSqlType = DatabaseTypeSQLite // Default to SQLite for logging SQL queries
 var UsingMySQL = false
-var UsingClickHouse = false

 var SQLitePath = "one-api.db?_busy_timeout=5000"
--- a/common/email-outlook-auth.go
+++ b/common/email-outlook-auth.go
@@ -1,40 +0,0 @@
-package common
-
-import (
-	"errors"
-	"net/smtp"
-	"strings"
-)
-
-type outlookAuth struct {
-	username, password string
-}
-
-func LoginAuth(username, password string) smtp.Auth {
-	return &outlookAuth{username, password}
-}
-
-func (a *outlookAuth) Start(_ *smtp.ServerInfo) (string, []byte, error) {
-	return "LOGIN", []byte{}, nil
-}
-
-func (a *outlookAuth) Next(fromServer []byte, more bool) ([]byte, error) {
-	if more {
-		switch string(fromServer) {
-		case "Username:":
-			return []byte(a.username), nil
-		case "Password:":
-			return []byte(a.password), nil
-		default:
-			return nil, errors.New("unknown fromServer")
-		}
-	}
-	return nil, nil
-}
-
-func isOutlookServer(server string) bool {
-	// 兼容多地区的outlook邮箱和ofb邮箱
-	// 其实应该加一个Option来区分是否用LOGIN的方式登录
-	// 先临时兼容一下
-	return strings.Contains(server, "outlook") || strings.Contains(server, "onmicrosoft")
-}
--- a/common/email.go
+++ b/common/email.go
@@ -5,39 +5,21 @@ import (
 	"encoding/base64"
 	"fmt"
 	"net/smtp"
-	"slices"
 	"strings"
 	"time"
 )

-func generateMessageID() (string, error) {
-	split := strings.Split(SMTPFrom, "@")
-	if len(split) < 2 {
-		return "", fmt.Errorf("invalid SMTP account")
-	}
-	domain := strings.Split(SMTPFrom, "@")[1]
-	return fmt.Sprintf("<%d.%s@%s>", time.Now().UnixNano(), GetRandomString(12), domain), nil
-}
-
 func SendEmail(subject string, receiver string, content string) error {
 	if SMTPFrom == "" { // for compatibility
 		SMTPFrom = SMTPAccount
 	}
-	id, err2 := generateMessageID()
-	if err2 != nil {
-		return err2
-	}
-	if SMTPServer == "" && SMTPAccount == "" {
-		return fmt.Errorf("SMTP 服务器未配置")
-	}
 	encodedSubject := fmt.Sprintf("=?UTF-8?B?%s?=", base64.StdEncoding.EncodeToString([]byte(subject)))
 	mail := []byte(fmt.Sprintf("To: %s\r\n"+
 		"From: %s<%s>\r\n"+
 		"Subject: %s\r\n"+
 		"Date: %s\r\n"+
-		"Message-ID: %s\r\n"+ // 添加 Message-ID 头
 		"Content-Type: text/html; charset=UTF-8\r\n\r\n%s\r\n",
-		receiver, SystemName, SMTPFrom, encodedSubject, time.Now().Format(time.RFC1123Z), id, content))
+		receiver, SystemName, SMTPFrom, encodedSubject, time.Now().Format(time.RFC1123Z), content))
 	auth := smtp.PlainAuth("", SMTPAccount, SMTPToken, SMTPServer)
 	addr := fmt.Sprintf("%s:%d", SMTPServer, SMTPPort)
 	to := strings.Split(receiver, ";")
@@ -80,11 +62,8 @@ func SendEmail(subject string, receiver string, content string) error {
 		if err != nil {
 			return err
 		}
-	} else if isOutlookServer(SMTPAccount) || slices.Contains(EmailLoginAuthServerList, SMTPServer) {
-		auth = LoginAuth(SMTPAccount, SMTPToken)
-		err = smtp.SendMail(addr, auth, SMTPFrom, to, mail)
 	} else {
-		err = smtp.SendMail(addr, auth, SMTPFrom, to, mail)
+		err = smtp.SendMail(addr, auth, SMTPAccount, to, mail)
 	}
 	return err
 }
--- a/common/env.go
+++ b/common/env.go
@@ -1,38 +0,0 @@
-package common
-
-import (
-	"fmt"
-	"os"
-	"strconv"
-)
-
-func GetEnvOrDefault(env string, defaultValue int) int {
-	if env == "" || os.Getenv(env) == "" {
-		return defaultValue
-	}
-	num, err := strconv.Atoi(os.Getenv(env))
-	if err != nil {
-		SysError(fmt.Sprintf("failed to parse %s: %s, using default value: %d", env, err.Error(), defaultValue))
-		return defaultValue
-	}
-	return num
-}
-
-func GetEnvOrDefaultString(env string, defaultValue string) string {
-	if env == "" || os.Getenv(env) == "" {
-		return defaultValue
-	}
-	return os.Getenv(env)
-}
-
-func GetEnvOrDefaultBool(env string, defaultValue bool) bool {
-	if env == "" || os.Getenv(env) == "" {
-		return defaultValue
-	}
-	b, err := strconv.ParseBool(os.Getenv(env))
-	if err != nil {
-		SysError(fmt.Sprintf("failed to parse %s: %s, using default value: %t", env, err.Error(), defaultValue))
-		return defaultValue
-	}
-	return b
-}
--- a/common/go-channel.go
+++ b/common/go-channel.go
@@ -1,9 +1,21 @@
 package common

 import (
-	"time"
+	"fmt"
+	"runtime/debug"
 )

+func SafeGoroutine(f func()) {
+	go func() {
+		defer func() {
+			if r := recover(); r != nil {
+				SysError(fmt.Sprintf("child goroutine panic occured: error: %v, stack: %s", r, string(debug.Stack())))
+			}
+		}()
+		f()
+	}()
+}
+
 func SafeSendBool(ch chan bool, value bool) (closed bool) {
 	defer func() {
 		// Recover from panic if one occured. A panic would mean the channel was closed.
@@ -33,21 +45,3 @@ func SafeSendString(ch chan string, value string) (closed bool) {
 	// If the code reaches here, then the channel was not closed.
 	return false
 }
-
-// SafeSendStringTimeout send, return true, else return false
-func SafeSendStringTimeout(ch chan string, value string, timeout int) (closed bool) {
-	defer func() {
-		// Recover from panic if one occured. A panic would mean the channel was closed.
-		if recover() != nil {
-			closed = false
-		}
-	}()
-
-	// This will panic if the channel is closed.
-	select {
-	case ch <- value:
-		return true
-	case <-time.After(time.Duration(timeout) * time.Second):
-		return false
-	}
-}
--- a/common/gopool.go
+++ b/common/gopool.go
@@ -1,24 +0,0 @@
-package common
-
-import (
-	"context"
-	"fmt"
-	"github.com/bytedance/gopkg/util/gopool"
-	"math"
-)
-
-var relayGoPool gopool.Pool
-
-func init() {
-	relayGoPool = gopool.NewPool("gopool.RelayPool", math.MaxInt32, gopool.NewConfig())
-	relayGoPool.SetPanicHandler(func(ctx context.Context, i interface{}) {
-		if stopChan, ok := ctx.Value("stop_chan").(chan bool); ok {
-			SafeSendBool(stopChan, true)
-		}
-		SysError(fmt.Sprintf("panic in gopool.RelayPool: %v", i))
-	})
-}
-
-func RelayCtxGo(ctx context.Context, f func()) {
-	relayGoPool.CtxGo(ctx, f)
-}
--- a/common/group-ratio.go
+++ b/common/group-ratio.go
@@ -0,0 +1,31 @@
+package common
+
+import "encoding/json"
+
+var GroupRatio = map[string]float64{
+	"default": 1,
+	"vip":     1,
+	"svip":    1,
+}
+
+func GroupRatio2JSONString() string {
+	jsonBytes, err := json.Marshal(GroupRatio)
+	if err != nil {
+		SysError("error marshalling model ratio: " + err.Error())
+	}
+	return string(jsonBytes)
+}
+
+func UpdateGroupRatioByJSONString(jsonStr string) error {
+	GroupRatio = make(map[string]float64)
+	return json.Unmarshal([]byte(jsonStr), &GroupRatio)
+}
+
+func GetGroupRatio(name string) float64 {
+	ratio, ok := GroupRatio[name]
+	if !ok {
+		SysError("group ratio not found: " + name)
+		return 1
+	}
+	return ratio
+}
--- a/common/init.go
+++ b/common/init.go
@@ -6,8 +6,6 @@ import (
 	"log"
 	"os"
 	"path/filepath"
-	"strconv"
-	"time"
 )

 var (
@@ -24,7 +22,7 @@ func printHelp() {
 	fmt.Println("Usage: one-api [--port <port>] [--log-dir <log directory>] [--version] [--help]")
 }

-func LoadEnv() {
+func init() {
 	flag.Parse()

 	if *PrintVersion {
@@ -47,11 +45,6 @@ func LoadEnv() {
 			SessionSecret = ss
 		}
 	}
-	if os.Getenv("CRYPTO_SECRET") != "" {
-		CryptoSecret = os.Getenv("CRYPTO_SECRET")
-	} else {
-		CryptoSecret = SessionSecret
-	}
 	if os.Getenv("SQLITE_PATH") != "" {
 		SQLitePath = os.Getenv("SQLITE_PATH")
 	}
@@ -68,31 +61,4 @@ func LoadEnv() {
 			}
 		}
 	}
-
-	// Initialize variables from constants.go that were using environment variables
-	DebugEnabled = os.Getenv("DEBUG") == "true"
-	MemoryCacheEnabled = os.Getenv("MEMORY_CACHE_ENABLED") == "true"
-	IsMasterNode = os.Getenv("NODE_TYPE") != "slave"
-
-	// Parse requestInterval and set RequestInterval
-	requestInterval, _ = strconv.Atoi(os.Getenv("POLLING_INTERVAL"))
-	RequestInterval = time.Duration(requestInterval) * time.Second
-
-	// Initialize variables with GetEnvOrDefault
-	SyncFrequency = GetEnvOrDefault("SYNC_FREQUENCY", 60)
-	BatchUpdateInterval = GetEnvOrDefault("BATCH_UPDATE_INTERVAL", 5)
-	RelayTimeout = GetEnvOrDefault("RELAY_TIMEOUT", 0)
-
-	// Initialize string variables with GetEnvOrDefaultString
-	GeminiSafetySetting = GetEnvOrDefaultString("GEMINI_SAFETY_SETTING", "BLOCK_NONE")
-	CohereSafetySetting = GetEnvOrDefaultString("COHERE_SAFETY_SETTING", "NONE")
-
-	// Initialize rate limit variables
-	GlobalApiRateLimitEnable = GetEnvOrDefaultBool("GLOBAL_API_RATE_LIMIT_ENABLE", true)
-	GlobalApiRateLimitNum = GetEnvOrDefault("GLOBAL_API_RATE_LIMIT", 180)
-	GlobalApiRateLimitDuration = int64(GetEnvOrDefault("GLOBAL_API_RATE_LIMIT_DURATION", 180))
-
-	GlobalWebRateLimitEnable = GetEnvOrDefaultBool("GLOBAL_WEB_RATE_LIMIT_ENABLE", true)
-	GlobalWebRateLimitNum = GetEnvOrDefault("GLOBAL_WEB_RATE_LIMIT", 60)
-	GlobalWebRateLimitDuration = int64(GetEnvOrDefault("GLOBAL_WEB_RATE_LIMIT_DURATION", 180))
 }
--- a/common/json.go
+++ b/common/json.go
@@ -1,18 +0,0 @@
-package common
-
-import (
-	"bytes"
-	"encoding/json"
-)
-
-func DecodeJson(data []byte, v any) error {
-	return json.NewDecoder(bytes.NewReader(data)).Decode(v)
-}
-
-func DecodeJsonStr(data string, v any) error {
-	return DecodeJson(StringToByteSlice(data), v)
-}
-
-func EncodeJson(v any) ([]byte, error) {
-	return json.Marshal(v)
-}
--- a/common/limiter/limiter.go
+++ b/common/limiter/limiter.go
@@ -1,89 +0,0 @@
-package limiter
-
-import (
-	"context"
-	_ "embed"
-	"fmt"
-	"github.com/go-redis/redis/v8"
-	"one-api/common"
-	"sync"
-)
-
-//go:embed lua/rate_limit.lua
-var rateLimitScript string
-
-type RedisLimiter struct {
-	client         *redis.Client
-	limitScriptSHA string
-}
-
-var (
-	instance *RedisLimiter
-	once     sync.Once
-)
-
-func New(ctx context.Context, r *redis.Client) *RedisLimiter {
-	once.Do(func() {
-		// 预加载脚本
-		limitSHA, err := r.ScriptLoad(ctx, rateLimitScript).Result()
-		if err != nil {
-			common.SysLog(fmt.Sprintf("Failed to load rate limit script: %v", err))
-		}
-		instance = &RedisLimiter{
-			client:         r,
-			limitScriptSHA: limitSHA,
-		}
-	})
-
-	return instance
-}
-
-func (rl *RedisLimiter) Allow(ctx context.Context, key string, opts ...Option) (bool, error) {
-	// 默认配置
-	config := &Config{
-		Capacity:  10,
-		Rate:      1,
-		Requested: 1,
-	}
-
-	// 应用选项模式
-	for _, opt := range opts {
-		opt(config)
-	}
-
-	// 执行限流
-	result, err := rl.client.EvalSha(
-		ctx,
-		rl.limitScriptSHA,
-		[]string{key},
-		config.Requested,
-		config.Rate,
-		config.Capacity,
-	).Int()
-
-	if err != nil {
-		return false, fmt.Errorf("rate limit failed: %w", err)
-	}
-	return result == 1, nil
-}
-
-// Config 配置选项模式
-type Config struct {
-	Capacity  int64
-	Rate      int64
-	Requested int64
-}
-
-type Option func(*Config)
-
-func WithCapacity(c int64) Option {
-	return func(cfg *Config) { cfg.Capacity = c }
-}
-
-func WithRate(r int64) Option {
-	return func(cfg *Config) { cfg.Rate = r }
-}
-
-func WithRequested(n int64) Option {
-	return func(cfg *Config) { cfg.Requested = n }
-}
--- a/common/limiter/lua/rate_limit.lua
+++ b/common/limiter/lua/rate_limit.lua
@@ -1,44 +0,0 @@
-- 令牌桶限流器
-- KEYS[1]: 限流器唯一标识
-- ARGV[1]: 请求令牌数 (通常为1)
-- ARGV[2]: 令牌生成速率 (每秒)
-- ARGV[3]: 桶容量
-
-local key = KEYS[1]
-local requested = tonumber(ARGV[1])
-local rate = tonumber(ARGV[2])
-local capacity = tonumber(ARGV[3])
-
-- 获取当前时间（Redis服务器时间）
-local now = redis.call('TIME')
-local nowInSeconds = tonumber(now[1])
-
-- 获取桶状态
-local bucket = redis.call('HMGET', key, 'tokens', 'last_time')
-local tokens = tonumber(bucket[1])
-local last_time = tonumber(bucket[2])
-
-- 初始化桶（首次请求或过期）
-if not tokens or not last_time then
-    tokens = capacity
-    last_time = nowInSeconds
-else
-    -- 计算新增令牌
-    local elapsed = nowInSeconds - last_time
-    local add_tokens = elapsed * rate
-    tokens = math.min(capacity, tokens + add_tokens)
-    last_time = nowInSeconds
-end
-
-- 判断是否允许请求
-local allowed = false
-if tokens >= requested then
-    tokens = tokens - requested
-    allowed = true
-end
-
---- 更新桶状态并设置过期时间
-redis.call('HMSET', key, 'tokens', tokens, 'last_time', last_time)
--redis.call('EXPIRE', key, math.ceil(capacity / rate) + 60) -- 适当延长过期时间
-
-return allowed and 1 or 0
--- a/common/logger.go
+++ b/common/logger.go
@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"github.com/bytedance/gopkg/util/gopool"
 	"github.com/gin-gonic/gin"
 	"io"
 	"log"
@@ -37,7 +36,7 @@ func SetupLogger() {
 			setupLogLock.Unlock()
 			setupLogWorking = false
 		}()
-		logPath := filepath.Join(*LogDir, fmt.Sprintf("oneapi-%s.log", time.Now().Format("20060102150405")))
+		logPath := filepath.Join(*LogDir, fmt.Sprintf("oneapi-%s.log", time.Now().Format("20060102")))
 		fd, err := os.OpenFile(logPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
 		if err != nil {
 			log.Fatal("failed to open log file")
@@ -81,9 +80,9 @@ func logHelper(ctx context.Context, level string, msg string) {
 	if logCount > maxLogCount && !setupLogWorking {
 		logCount = 0
 		setupLogWorking = true
-		gopool.Go(func() {
+		go func() {
 			SetupLogger()
-		})
+		}()
 	}
 }

@@ -101,14 +100,6 @@ func LogQuota(quota int) string {
 	}
 }

-func FormatQuota(quota int) string {
-	if DisplayInCurrencyEnabled {
-		return fmt.Sprintf("＄%.6f", float64(quota)/QuotaPerUnit)
-	} else {
-		return fmt.Sprintf("%d", quota)
-	}
-}
-
 // LogJson 仅供测试使用 only for test
 func LogJson(ctx context.Context, msg string, obj any) {
 	jsonStr, err := json.Marshal(obj)
--- a/common/model-ratio.go
+++ b/common/model-ratio.go
@@ -0,0 +1,358 @@
+package common
+
+import (
+	"encoding/json"
+	"strings"
+)
+
+// 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-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,    // $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-4o":                    2.5,  // $0.01 / 1K tokens
+	"gpt-4o-2024-05-13":         2.5,  // $0.01 / 1K tokens
+	"gpt-4-turbo":               5,    // $0.01 / 1K tokens
+	"gpt-4-turbo-2024-04-09":    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,
+	"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 //renamed to ERNIE-3.5-8K
+	"ERNIE-Bot-turbo":                0.5715, // ￥0.008 / 1k tokens //renamed to ERNIE-Lite-8K
+	"ERNIE-Bot-4":                    8.572,  // ￥0.12 / 1k tokens //renamed to ERNIE-4.0-8K
+	"ERNIE-4.0-8K":                   8.572,  // ￥0.12 / 1k tokens
+	"ERNIE-3.5-8K":                   0.8572, // ￥0.012 / 1k tokens
+	"ERNIE-Speed-8K":                 0.2858, // ￥0.004 / 1k tokens
+	"ERNIE-Speed-128K":               0.2858, // ￥0.004 / 1k tokens
+	"ERNIE-Lite-8K":                  0.2143, // ￥0.003 / 1k tokens
+	"ERNIE-Tiny-8K":                  0.0715, // ￥0.001 / 1k tokens
+	"ERNIE-Character-8K":             0.2858, // ￥0.004 / 1k tokens
+	"ERNIE-Functions-8K":             0.2858, // ￥0.004 / 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.5-flash-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
+	"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
+	"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,
+	"deepseek-chat":         0.07,
+	"deepseek-coder":        0.07,
+	// 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,
+}
+
+var defaultModelPrice = map[string]float64{
+	"dall-e-3":          0.04,
+	"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
+
+var CompletionRatio map[string]float64 = nil
+var defaultCompletionRatio = map[string]float64{
+	"gpt-4-gizmo-*": 2,
+	"gpt-4-all":     2,
+}
+
+func ModelPrice2JSONString() string {
+	if modelPrice == nil {
+		modelPrice = defaultModelPrice
+	}
+	jsonBytes, err := json.Marshal(modelPrice)
+	if err != nil {
+		SysError("error marshalling model price: " + err.Error())
+	}
+	return string(jsonBytes)
+}
+
+func UpdateModelPriceByJSONString(jsonStr string) error {
+	modelPrice = make(map[string]float64)
+	return json.Unmarshal([]byte(jsonStr), &modelPrice)
+}
+
+// GetModelPrice 返回模型的价格，如果模型不存在则返回-1，false
+func GetModelPrice(name string, printErr bool) (float64, bool) {
+	if modelPrice == nil {
+		modelPrice = defaultModelPrice
+	}
+	if strings.HasPrefix(name, "gpt-4-gizmo") {
+		name = "gpt-4-gizmo-*"
+	}
+	price, ok := modelPrice[name]
+	if !ok {
+		if printErr {
+			SysError("model price not found: " + name)
+		}
+		return -1, false
+	}
+	return price, true
+}
+
+func GetModelPriceMap() map[string]float64 {
+	if modelPrice == nil {
+		modelPrice = defaultModelPrice
+	}
+	return modelPrice
+}
+
+func ModelRatio2JSONString() string {
+	if modelRatio == nil {
+		modelRatio = defaultModelRatio
+	}
+	jsonBytes, err := json.Marshal(modelRatio)
+	if err != nil {
+		SysError("error marshalling model ratio: " + err.Error())
+	}
+	return string(jsonBytes)
+}
+
+func UpdateModelRatioByJSONString(jsonStr string) error {
+	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]
+	if !ok {
+		SysError("model ratio not found: " + name)
+		return 30
+	}
+	return ratio
+}
+
+func DefaultModelRatio2JSONString() string {
+	jsonBytes, err := json.Marshal(defaultModelRatio)
+	if err != nil {
+		SysError("error marshalling model ratio: " + err.Error())
+	}
+	return string(jsonBytes)
+}
+
+func GetDefaultModelRatioMap() map[string]float64 {
+	return defaultModelRatio
+}
+
+func CompletionRatio2JSONString() string {
+	if CompletionRatio == nil {
+		CompletionRatio = defaultCompletionRatio
+	}
+	jsonBytes, err := json.Marshal(CompletionRatio)
+	if err != nil {
+		SysError("error marshalling completion ratio: " + err.Error())
+	}
+	return string(jsonBytes)
+}
+
+func UpdateCompletionRatioByJSONString(jsonStr string) error {
+	CompletionRatio = make(map[string]float64)
+	return json.Unmarshal([]byte(jsonStr), &CompletionRatio)
+}
+
+func GetCompletionRatio(name string) float64 {
+	if strings.HasPrefix(name, "gpt-4-gizmo") {
+		name = "gpt-4-gizmo-*"
+	}
+	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
+		}
+		if strings.HasSuffix(name, "1106") {
+			return 2
+		}
+		return 4.0 / 3.0
+	}
+	if strings.HasPrefix(name, "gpt-4") && !strings.HasSuffix(name, "-all") && !strings.HasSuffix(name, "-gizmo-*") {
+		if strings.HasPrefix(name, "gpt-4-turbo") || strings.HasSuffix(name, "preview") || strings.HasPrefix(name, "gpt-4o") {
+			return 3
+		}
+		return 2
+	}
+	if strings.Contains(name, "claude-instant-1") {
+		return 3
+	} else if strings.Contains(name, "claude-2") {
+		return 3
+	} else if strings.Contains(name, "claude-3") {
+		return 5
+	}
+	if strings.HasPrefix(name, "mistral-") {
+		return 3
+	}
+	if strings.HasPrefix(name, "gemini-") {
+		return 3
+	}
+	if strings.HasPrefix(name, "command") {
+		switch name {
+		case "command-r":
+			return 3
+		case "command-r-plus":
+			return 5
+		default:
+			return 2
+		}
+	}
+	if strings.HasPrefix(name, "deepseek") {
+		return 2
+	}
+	if strings.HasPrefix(name, "ERNIE-Speed-") {
+		return 2
+	} else if strings.HasPrefix(name, "ERNIE-Lite-") {
+		return 2
+	} else if strings.HasPrefix(name, "ERNIE-Character") {
+		return 2
+	} else if strings.HasPrefix(name, "ERNIE-Functions") {
+		return 2
+	}
+	switch name {
+	case "llama2-70b-4096":
+		return 0.8 / 0.64
+	case "llama3-8b-8192":
+		return 2
+	case "llama3-70b-8192":
+		return 0.79 / 0.59
+	}
+	if ratio, ok := CompletionRatio[name]; ok {
+		return ratio
+	}
+	return 1
+}
+
+func GetCompletionRatioMap() map[string]float64 {
+	if CompletionRatio == nil {
+		CompletionRatio = defaultCompletionRatio
+	}
+	return CompletionRatio
+}
--- a/common/redis.go
+++ b/common/redis.go
@@ -2,15 +2,9 @@ package common

 import (
 	"context"
-	"errors"
-	"fmt"
-	"os"
-	"reflect"
-	"strconv"
-	"time"
-
 	"github.com/go-redis/redis/v8"
-	"gorm.io/gorm"
+	"os"
+	"time"
 )

 var RDB *redis.Client
@@ -32,7 +26,6 @@ func InitRedisClient() (err error) {
 	if err != nil {
 		FatalLog("failed to parse Redis connection string: " + err.Error())
 	}
-	opt.PoolSize = GetEnvOrDefault("REDIS_POOL_SIZE", 10)
 	RDB = redis.NewClient(opt)

 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
@@ -42,10 +35,6 @@ func InitRedisClient() (err error) {
 	if err != nil {
 		FatalLog("Redis ping test failed: " + err.Error())
 	}
-	if DebugEnabled {
-		SysLog(fmt.Sprintf("Redis connected to %s", opt.Addr))
-		SysLog(fmt.Sprintf("Redis database: %d", opt.DB))
-	}
 	return err
 }

@@ -58,202 +47,48 @@ func ParseRedisOption() *redis.Options {
 }

 func RedisSet(key string, value string, expiration time.Duration) error {
-	if DebugEnabled {
-		SysLog(fmt.Sprintf("Redis SET: key=%s, value=%s, expiration=%v", key, value, expiration))
-	}
 	ctx := context.Background()
 	return RDB.Set(ctx, key, value, expiration).Err()
 }

 func RedisGet(key string) (string, error) {
-	if DebugEnabled {
-		SysLog(fmt.Sprintf("Redis GET: key=%s", key))
-	}
 	ctx := context.Background()
-	val, err := RDB.Get(ctx, key).Result()
-	return val, err
+	return RDB.Get(ctx, key).Result()
 }

-//func RedisExpire(key string, expiration time.Duration) error {
-//	ctx := context.Background()
-//	return RDB.Expire(ctx, key, expiration).Err()
-//}
-//
-//func RedisGetEx(key string, expiration time.Duration) (string, error) {
-//	ctx := context.Background()
-//	return RDB.GetSet(ctx, key, expiration).Result()
-//}
+func RedisExpire(key string, expiration time.Duration) error {
+	ctx := context.Background()
+	return RDB.Expire(ctx, key, expiration).Err()
+}
+
+func RedisGetEx(key string, expiration time.Duration) (string, error) {
+	ctx := context.Background()
+	return RDB.GetSet(ctx, key, expiration).Result()
+}

 func RedisDel(key string) error {
-	if DebugEnabled {
-		SysLog(fmt.Sprintf("Redis DEL: key=%s", key))
-	}
 	ctx := context.Background()
 	return RDB.Del(ctx, key).Err()
 }

-func RedisDelKey(key string) error {
-	if DebugEnabled {
-		SysLog(fmt.Sprintf("Redis DEL Key: key=%s", key))
-	}
-	ctx := context.Background()
-	return RDB.Del(ctx, key).Err()
-}
+func RedisDecrease(key string, value int64) error {

-func RedisHSetObj(key string, obj interface{}, expiration time.Duration) error {
-	if DebugEnabled {
-		SysLog(fmt.Sprintf("Redis HSET: key=%s, obj=%+v, expiration=%v", key, obj, expiration))
-	}
-	ctx := context.Background()
-
-	data := make(map[string]interface{})
-
-	// 使用反射遍历结构体字段
-	v := reflect.ValueOf(obj).Elem()
-	t := v.Type()
-	for i := 0; i < v.NumField(); i++ {
-		field := t.Field(i)
-		value := v.Field(i)
-
-		// Skip DeletedAt field
-		if field.Type.String() == "gorm.DeletedAt" {
-			continue
-		}
-
-		// 处理指针类型
-		if value.Kind() == reflect.Ptr {
-			if value.IsNil() {
-				data[field.Name] = ""
-				continue
-			}
-			value = value.Elem()
-		}
-
-		// 处理布尔类型
-		if value.Kind() == reflect.Bool {
-			data[field.Name] = strconv.FormatBool(value.Bool())
-			continue
-		}
-
-		// 其他类型直接转换为字符串
-		data[field.Name] = fmt.Sprintf("%v", value.Interface())
-	}
-
-	txn := RDB.TxPipeline()
-	txn.HSet(ctx, key, data)
-
-	// 只有在 expiration 大于 0 时才设置过期时间
-	if expiration > 0 {
-		txn.Expire(ctx, key, expiration)
-	}
-
-	_, err := txn.Exec(ctx)
-	if err != nil {
-		return fmt.Errorf("failed to execute transaction: %w", err)
-	}
-	return nil
-}
-
-func RedisHGetObj(key string, obj interface{}) error {
-	if DebugEnabled {
-		SysLog(fmt.Sprintf("Redis HGETALL: key=%s", key))
-	}
-	ctx := context.Background()
-
-	result, err := RDB.HGetAll(ctx, key).Result()
-	if err != nil {
-		return fmt.Errorf("failed to load hash from Redis: %w", err)
-	}
-
-	if len(result) == 0 {
-		return fmt.Errorf("key %s not found in Redis", key)
-	}
-
-	// Handle both pointer and non-pointer values
-	val := reflect.ValueOf(obj)
-	if val.Kind() != reflect.Ptr {
-		return fmt.Errorf("obj must be a pointer to a struct, got %T", obj)
-	}
-
-	v := val.Elem()
-	if v.Kind() != reflect.Struct {
-		return fmt.Errorf("obj must be a pointer to a struct, got pointer to %T", v.Interface())
-	}
-
-	t := v.Type()
-	for i := 0; i < v.NumField(); i++ {
-		field := t.Field(i)
-		fieldName := field.Name
-		if value, ok := result[fieldName]; ok {
-			fieldValue := v.Field(i)
-
-			// Handle pointer types
-			if fieldValue.Kind() == reflect.Ptr {
-				if value == "" {
-					continue
-				}
-				if fieldValue.IsNil() {
-					fieldValue.Set(reflect.New(fieldValue.Type().Elem()))
-				}
-				fieldValue = fieldValue.Elem()
-			}
-
-			// Enhanced type handling for Token struct
-			switch fieldValue.Kind() {
-			case reflect.String:
-				fieldValue.SetString(value)
-			case reflect.Int, reflect.Int64:
-				intValue, err := strconv.ParseInt(value, 10, 64)
-				if err != nil {
-					return fmt.Errorf("failed to parse int field %s: %w", fieldName, err)
-				}
-				fieldValue.SetInt(intValue)
-			case reflect.Bool:
-				boolValue, err := strconv.ParseBool(value)
-				if err != nil {
-					return fmt.Errorf("failed to parse bool field %s: %w", fieldName, err)
-				}
-				fieldValue.SetBool(boolValue)
-			case reflect.Struct:
-				// Special handling for gorm.DeletedAt
-				if fieldValue.Type().String() == "gorm.DeletedAt" {
-					if value != "" {
-						timeValue, err := time.Parse(time.RFC3339, value)
-						if err != nil {
-							return fmt.Errorf("failed to parse DeletedAt field %s: %w", fieldName, err)
-						}
-						fieldValue.Set(reflect.ValueOf(gorm.DeletedAt{Time: timeValue, Valid: true}))
-					}
-				}
-			default:
-				return fmt.Errorf("unsupported field type: %s for field %s", fieldValue.Kind(), fieldName)
-			}
-		}
-	}
-
-	return nil
-}
-
-// RedisIncr Add this function to handle atomic increments
-func RedisIncr(key string, delta int64) error {
-	if DebugEnabled {
-		SysLog(fmt.Sprintf("Redis INCR: key=%s, delta=%d", key, delta))
-	}
 	// 检查键的剩余生存时间
 	ttlCmd := RDB.TTL(context.Background(), key)
 	ttl, err := ttlCmd.Result()
-	if err != nil && !errors.Is(err, redis.Nil) {
-		return fmt.Errorf("failed to get TTL: %w", err)
+	if err != nil {
+		// 失败则尝试直接减少
+		return RDB.DecrBy(context.Background(), key, value).Err()
 	}

-	// 只有在 key 存在且有 TTL 时才需要特殊处理
+	// 如果剩余生存时间大于0，则进行减少操作
 	if ttl > 0 {
 		ctx := context.Background()
 		// 开始一个Redis事务
 		txn := RDB.TxPipeline()

 		// 减少余额
-		decrCmd := txn.IncrBy(ctx, key, delta)
+		decrCmd := txn.DecrBy(ctx, key, value)
 		if err := decrCmd.Err(); err != nil {
 			return err // 如果减少失败，则直接返回错误
 		}
@@ -264,60 +99,8 @@ func RedisIncr(key string, delta int64) error {
 		// 执行事务
 		_, err = txn.Exec(ctx)
 		return err
-	}
-	return nil
-}
-
-func RedisHIncrBy(key, field string, delta int64) error {
-	if DebugEnabled {
-		SysLog(fmt.Sprintf("Redis HINCRBY: key=%s, field=%s, delta=%d", key, field, delta))
-	}
-	ttlCmd := RDB.TTL(context.Background(), key)
-	ttl, err := ttlCmd.Result()
-	if err != nil && !errors.Is(err, redis.Nil) {
-		return fmt.Errorf("failed to get TTL: %w", err)
-	}
-
-	if ttl > 0 {
-		ctx := context.Background()
-		txn := RDB.TxPipeline()
-
-		incrCmd := txn.HIncrBy(ctx, key, field, delta)
-		if err := incrCmd.Err(); err != nil {
-			return err
-		}
-
-		txn.Expire(ctx, key, ttl)
-
-		_, err = txn.Exec(ctx)
-		return err
-	}
-	return nil
-}
-
-func RedisHSetField(key, field string, value interface{}) error {
-	if DebugEnabled {
-		SysLog(fmt.Sprintf("Redis HSET field: key=%s, field=%s, value=%v", key, field, value))
-	}
-	ttlCmd := RDB.TTL(context.Background(), key)
-	ttl, err := ttlCmd.Result()
-	if err != nil && !errors.Is(err, redis.Nil) {
-		return fmt.Errorf("failed to get TTL: %w", err)
-	}
-
-	if ttl > 0 {
-		ctx := context.Background()
-		txn := RDB.TxPipeline()
-
-		hsetCmd := txn.HSet(ctx, key, field, value)
-		if err := hsetCmd.Err(); err != nil {
-			return err
-		}
-
-		txn.Expire(ctx, key, ttl)
-
-		_, err = txn.Exec(ctx)
-		return err
+	} else {
+		_ = RedisDel(key)
 	}
 	return nil
 }
--- a/common/str.go
+++ b/common/str.go
@@ -1,70 +1,80 @@
 package common

 import (
-	"encoding/json"
-	"math/rand"
-	"strconv"
-	"unsafe"
+	"bytes"
+	"fmt"
+	goahocorasick "github.com/anknown/ahocorasick"
+	"one-api/constant"
+	"strings"
 )

-func GetStringIfEmpty(str string, defaultValue string) string {
-	if str == "" {
-		return defaultValue
+func SundaySearch(text string, pattern string) bool {
+	// 计算偏移表
+	offset := make(map[rune]int)
+	for i, c := range pattern {
+		offset[c] = len(pattern) - i
 	}
-	return str
+
+	// 文本串长度和模式串长度
+	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 GetRandomString(length int) string {
-	//rand.Seed(time.Now().UnixNano())
-	key := make([]byte, length)
-	for i := 0; i < length; i++ {
-		key[i] = keyChars[rand.Intn(len(keyChars))]
+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 string(key)
+	return result
 }

-func MapToJsonStr(m map[string]interface{}) string {
-	bytes, err := json.Marshal(m)
-	if err != nil {
-		return ""
-	}
-	return string(bytes)
-}
-
-func StrToMap(str string) map[string]interface{} {
-	m := make(map[string]interface{})
-	err := json.Unmarshal([]byte(str), &m)
-	if err != nil {
+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 IsJsonStr(str string) bool {
-	var js map[string]interface{}
-	return json.Unmarshal([]byte(str), &js) == nil
-}
+func readRunes() [][]rune {
+	var dict [][]rune

-func String2Int(str string) int {
-	num, err := strconv.Atoi(str)
-	if err != nil {
-		return 0
+	for _, word := range constant.SensitiveWords {
+		word = strings.ToLower(word)
+		l := bytes.TrimSpace([]byte(word))
+		dict = append(dict, bytes.Runes(l))
 	}
-	return num
-}

-func StringsContains(strs []string, str string) bool {
-	for _, s := range strs {
-		if s == str {
-			return true
-		}
-	}
-	return false
-}
-
-// StringToByteSlice []byte only read, panic on append
-func StringToByteSlice(s string) []byte {
-	tmp1 := (*[2]uintptr)(unsafe.Pointer(&s))
-	tmp2 := [3]uintptr{tmp1[0], tmp1[1], tmp1[1]}
-	return *(*[]byte)(unsafe.Pointer(&tmp2))
+	return dict
 }
--- a/common/topup-ratio.go
+++ b/common/topup-ratio.go
@@ -1,8 +1,6 @@
 package common

-import (
-	"encoding/json"
-)
+import "encoding/json"

 var TopupGroupRatio = map[string]float64{
 	"default": 1,
--- a/common/utils.go
+++ b/common/utils.go
@@ -1,28 +1,20 @@
 package common

 import (
-	"bytes"
-	"context"
-	crand "crypto/rand"
-	"encoding/base64"
 	"encoding/json"
 	"fmt"
+	"github.com/google/uuid"
 	"html/template"
-	"io"
 	"log"
-	"math/big"
 	"math/rand"
 	"net"
-	"net/url"
 	"os"
 	"os/exec"
 	"runtime"
 	"strconv"
 	"strings"
 	"time"
-
-	"github.com/google/uuid"
-	"github.com/pkg/errors"
+	"unsafe"
 )

 func OpenBrowser(url string) {
@@ -139,11 +131,6 @@ func IntMax(a int, b int) int {
 	}
 }

-func IsIP(s string) bool {
-	ip := net.ParseIP(s)
-	return ip != nil
-}
-
 func GetUUID() string {
 	code := uuid.New().String()
 	code = strings.Replace(code, "-", "", -1)
@@ -153,35 +140,33 @@ func GetUUID() string {
 const keyChars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

 func init() {
-	rand.New(rand.NewSource(time.Now().UnixNano()))
+	rand.Seed(time.Now().UnixNano())
 }

-func GenerateRandomCharsKey(length int) (string, error) {
-	b := make([]byte, length)
-	maxI := big.NewInt(int64(len(keyChars)))
-
-	for i := range b {
-		n, err := crand.Int(crand.Reader, maxI)
-		if err != nil {
-			return "", err
-		}
-		b[i] = keyChars[n.Int64()]
-	}
-
-	return string(b), nil
-}
-
-func GenerateRandomKey(length int) (string, error) {
-	bytes := make([]byte, length*3/4) // 对于48位的输出，这里应该是36
-	if _, err := crand.Read(bytes); err != nil {
-		return "", err
-	}
-	return base64.StdEncoding.EncodeToString(bytes), nil
-}
-
-func GenerateKey() (string, error) {
+func GenerateKey() string {
 	//rand.Seed(time.Now().UnixNano())
-	return GenerateRandomCharsKey(48)
+	key := make([]byte, 48)
+	for i := 0; i < 16; i++ {
+		key[i] = keyChars[rand.Intn(len(keyChars))]
+	}
+	uuid_ := GetUUID()
+	for i := 0; i < 32; i++ {
+		c := uuid_[i]
+		if i%2 == 0 && c >= 'a' && c <= 'z' {
+			c = c - 'a' + 'A'
+		}
+		key[i+16] = c
+	}
+	return string(key)
+}
+
+func GetRandomString(length int) string {
+	//rand.Seed(time.Now().UnixNano())
+	key := make([]byte, length)
+	for i := 0; i < length; i++ {
+		key[i] = keyChars[rand.Intn(len(keyChars))]
+	}
+	return string(key)
 }

 func GetRandomInt(max int) int {
@@ -206,99 +191,79 @@ func Max(a int, b int) int {
 	}
 }

+func GetOrDefault(env string, defaultValue int) int {
+	if env == "" || os.Getenv(env) == "" {
+		return defaultValue
+	}
+	num, err := strconv.Atoi(os.Getenv(env))
+	if err != nil {
+		SysError(fmt.Sprintf("failed to parse %s: %s, using default value: %d", env, err.Error(), defaultValue))
+		return defaultValue
+	}
+	return num
+}
+
+func GetOrDefaultString(env string, defaultValue string) string {
+	if env == "" || os.Getenv(env) == "" {
+		return defaultValue
+	}
+	return os.Getenv(env)
+}
+
 func MessageWithRequestId(message string, id string) string {
 	return fmt.Sprintf("%s (request id: %s)", message, id)
 }

+func String2Int(str string) int {
+	num, err := strconv.Atoi(str)
+	if err != nil {
+		return 0
+	}
+	return num
+}
+
+func StringsContains(strs []string, str string) bool {
+	for _, s := range strs {
+		if s == str {
+			return true
+		}
+	}
+	return false
+}
+
+// StringToByteSlice []byte only read, panic on append
+func StringToByteSlice(s string) []byte {
+	tmp1 := (*[2]uintptr)(unsafe.Pointer(&s))
+	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)
 }

-func GetPointer[T any](v T) *T {
-	return &v
+func MapToJsonStr(m map[string]interface{}) string {
+	bytes, err := json.Marshal(m)
+	if err != nil {
+		return ""
+	}
+	return string(bytes)
 }

-func Any2Type[T any](data any) (T, error) {
-	var zero T
-	bytes, err := json.Marshal(data)
+func MapToJsonStrFloat(m map[string]float64) string {
+	bytes, err := json.Marshal(m)
 	if err != nil {
-		return zero, err
+		return ""
 	}
-	var res T
-	err = json.Unmarshal(bytes, &res)
-	if err != nil {
-		return zero, err
-	}
-	return res, nil
+	return string(bytes)
 }

-// SaveTmpFile saves data to a temporary file. The filename would be apppended with a random string.
-func SaveTmpFile(filename string, data io.Reader) (string, error) {
-	f, err := os.CreateTemp(os.TempDir(), filename)
+func StrToMap(str string) map[string]interface{} {
+	m := make(map[string]interface{})
+	err := json.Unmarshal([]byte(str), &m)
 	if err != nil {
-		return "", errors.Wrapf(err, "failed to create temporary file %s", filename)
+		return nil
 	}
-	defer f.Close()
-
-	_, err = io.Copy(f, data)
-	if err != nil {
-		return "", errors.Wrapf(err, "failed to copy data to temporary file %s", filename)
-	}
-
-	return f.Name(), nil
-}
-
-// GetAudioDuration returns the duration of an audio file in seconds.
-func GetAudioDuration(ctx context.Context, filename string, ext string) (float64, error) {
-	// ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 {{input}}
-	c := exec.CommandContext(ctx, "ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", filename)
-	output, err := c.Output()
-	if err != nil {
-		return 0, errors.Wrap(err, "failed to get audio duration")
-	}
-  durationStr := string(bytes.TrimSpace(output))
-  if durationStr == "N/A" {
-    // Create a temporary output file name
-    tmpFp, err := os.CreateTemp("", "audio-*"+ext)
-    if err != nil {
-      return 0, errors.Wrap(err, "failed to create temporary file")
-    }
-    tmpName := tmpFp.Name()
-    // Close immediately so ffmpeg can open the file on Windows.
-    _ = tmpFp.Close()
-    defer os.Remove(tmpName)
-
-    // ffmpeg -y -i filename -vcodec copy -acodec copy <tmpName>
-    ffmpegCmd := exec.CommandContext(ctx, "ffmpeg", "-y", "-i", filename, "-vcodec", "copy", "-acodec", "copy", tmpName)
-    if err := ffmpegCmd.Run(); err != nil {
-      return 0, errors.Wrap(err, "failed to run ffmpeg")
-    }
-
-    // Recalculate the duration of the new file
-    c = exec.CommandContext(ctx, "ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", tmpName)
-    output, err := c.Output()
-    if err != nil {
-      return 0, errors.Wrap(err, "failed to get audio duration after ffmpeg")
-    }
-    durationStr = string(bytes.TrimSpace(output))
-  }
-	return strconv.ParseFloat(durationStr, 64)
-}
-
-// BuildURL concatenates base and endpoint, returns the complete url string
-func BuildURL(base string, endpoint string) string {
-	u, err := url.Parse(base)
-	if err != nil {
-		return base + endpoint
-	}
-	end := endpoint
-	if end == "" {
-		end = "/"
-	}
-	ref, err := url.Parse(end)
-	if err != nil {
-		return base + endpoint
-	}
-	return u.ResolveReference(ref).String()
+	return m
 }
--- a/constant/azure.go
+++ b/constant/azure.go
@@ -1,5 +0,0 @@
-package constant
-
-import "time"
-
-var AzureNoRemoveDotTime = time.Date(2025, time.May, 10, 0, 0, 0, 0, time.UTC).Unix()
--- a/constant/cache_key.go
+++ b/constant/cache_key.go
@@ -1,21 +0,0 @@
-package constant
-
-import "one-api/common"
-
-// 使用函数来避免初始化顺序带来的赋值问题
-func RedisKeyCacheSeconds() int {
-	return common.SyncFrequency
-}
-
-// Cache keys
-const (
-	UserGroupKeyFmt    = "user_group:%d"
-	UserQuotaKeyFmt    = "user_quota:%d"
-	UserEnabledKeyFmt  = "user_enabled:%d"
-	UserUsernameKeyFmt = "user_name:%d"
-)
-
-const (
-	TokenFiledRemainQuota = "RemainQuota"
-	TokenFieldGroup       = "Group"
-)
--- a/constant/channel_setting.go
+++ b/constant/channel_setting.go
@@ -1,7 +0,0 @@
-package constant
-
-var (
-	ForceFormat                     = "force_format"        // ForceFormat 强制格式化为OpenAI格式
-	ChanelSettingProxy              = "proxy"               // Proxy 代理
-	ChannelSettingThinkingToContent = "thinking_to_content" // ThinkingToContent
-)
--- a/constant/context_key.go
+++ b/constant/context_key.go
@@ -1,11 +0,0 @@
-package constant
-
-const (
-	ContextKeyRequestStartTime = "request_start_time"
-	ContextKeyUserSetting      = "user_setting"
-	ContextKeyUserQuota        = "user_quota"
-	ContextKeyUserStatus       = "user_status"
-	ContextKeyUserEmail        = "user_email"
-	ContextKeyUserGroup        = "user_group"
-	ContextKeyUsingGroup       = "group"
-)
--- a/constant/env.go
+++ b/constant/env.go
@@ -1,55 +0,0 @@
-package constant
-
-import (
-	"one-api/common"
-)
-
-var StreamingTimeout int
-var DifyDebug bool
-var MaxFileDownloadMB int
-var ForceStreamOption bool
-var GetMediaToken bool
-var GetMediaTokenNotStream bool
-var UpdateTask bool
-var AzureDefaultAPIVersion string
-var GeminiVisionMaxImageNum int
-var NotifyLimitCount int
-var NotificationLimitDurationMinute int
-var GenerateDefaultToken bool
-var ErrorLogEnabled bool
-
-//var GeminiModelMap = map[string]string{
-//	"gemini-1.0-pro": "v1",
-//}
-
-func InitEnv() {
-	StreamingTimeout = common.GetEnvOrDefault("STREAMING_TIMEOUT", 60)
-	DifyDebug = common.GetEnvOrDefaultBool("DIFY_DEBUG", true)
-	MaxFileDownloadMB = common.GetEnvOrDefault("MAX_FILE_DOWNLOAD_MB", 20)
-	// ForceStreamOption 覆盖请求参数，强制返回usage信息
-	ForceStreamOption = common.GetEnvOrDefaultBool("FORCE_STREAM_OPTION", true)
-	GetMediaToken = common.GetEnvOrDefaultBool("GET_MEDIA_TOKEN", true)
-	GetMediaTokenNotStream = common.GetEnvOrDefaultBool("GET_MEDIA_TOKEN_NOT_STREAM", true)
-	UpdateTask = common.GetEnvOrDefaultBool("UPDATE_TASK", true)
-	AzureDefaultAPIVersion = common.GetEnvOrDefaultString("AZURE_DEFAULT_API_VERSION", "2025-04-01-preview")
-	GeminiVisionMaxImageNum = common.GetEnvOrDefault("GEMINI_VISION_MAX_IMAGE_NUM", 16)
-	NotifyLimitCount = common.GetEnvOrDefault("NOTIFY_LIMIT_COUNT", 2)
-	NotificationLimitDurationMinute = common.GetEnvOrDefault("NOTIFICATION_LIMIT_DURATION_MINUTE", 10)
-	// GenerateDefaultToken 是否生成初始令牌，默认关闭。
-	GenerateDefaultToken = common.GetEnvOrDefaultBool("GENERATE_DEFAULT_TOKEN", false)
-	// 是否启用错误日志
-	ErrorLogEnabled = common.GetEnvOrDefaultBool("ERROR_LOG_ENABLED", false)
-
-	//modelVersionMapStr := strings.TrimSpace(os.Getenv("GEMINI_MODEL_MAP"))
-	//if modelVersionMapStr == "" {
-	//	return
-	//}
-	//for _, pair := range strings.Split(modelVersionMapStr, ",") {
-	//	parts := strings.Split(pair, ":")
-	//	if len(parts) == 2 {
-	//		GeminiModelMap[parts[0]] = parts[1]
-	//	} else {
-	//		common.SysError(fmt.Sprintf("invalid model version map: %s", pair))
-	//	}
-	//}
-}
--- a/constant/finish_reason.go
+++ b/constant/finish_reason.go
@@ -1,9 +0,0 @@
-package constant
-
-var (
-	FinishReasonStop          = "stop"
-	FinishReasonToolCalls     = "tool_calls"
-	FinishReasonLength        = "length"
-	FinishReasonFunctionCall  = "function_call"
-	FinishReasonContentFilter = "content_filter"
-)
--- a/constant/midjourney.go
+++ b/constant/midjourney.go
@@ -1,5 +1,10 @@
 package constant

+var MjNotifyEnabled = false
+var MjAccountFilterEnabled = false
+var MjModeClearEnabled = false
+var MjForwardUrlEnabled = true
+
 const (
 	MjErrorUnknown = 5
 	MjRequestError = 4
@@ -21,7 +26,6 @@ const (
 	MjActionLowVariation  = "LOW_VARIATION"
 	MjActionPan           = "PAN"
 	MjActionSwapFace      = "SWAP_FACE"
-	MjActionUpload        = "UPLOAD"
 )

 var MidjourneyModel2Action = map[string]string{
@@ -40,5 +44,4 @@ var MidjourneyModel2Action = map[string]string{
 	"mj_low_variation":  MjActionLowVariation,
 	"mj_pan":            MjActionPan,
 	"swap_face":         MjActionSwapFace,
-	"mj_upload":         MjActionUpload,
 }
--- 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
@@ -1,4 +1,4 @@
-package setting
+package constant

 import "strings"

--- a/constant/setup.go
+++ b/constant/setup.go
@@ -1,3 +0,0 @@
-package constant
-
-var Setup = false
--- a/setting/system_setting.go
+++ b/setting/system_setting.go
@@ -1,9 +1,8 @@
-package setting
+package constant

 var ServerAddress = "http://localhost:3000"
 var WorkerUrl = ""
 var WorkerValidKey = ""
-var WorkerAllowHttpImageRequestEnabled = false

 func EnableWorker() bool {
 	return WorkerUrl != ""
--- a/constant/task.go
+++ b/constant/task.go
@@ -5,7 +5,6 @@ type TaskPlatform string
 const (
 	TaskPlatformSuno       TaskPlatform = "suno"
 	TaskPlatformMidjourney              = "mj"
-	TaskPlatformKling      TaskPlatform = "kling"
 )

 const (
--- a/constant/user_setting.go
+++ b/constant/user_setting.go
@@ -1,16 +0,0 @@
-package constant
-
-var (
-	UserSettingNotifyType            = "notify_type"                    // QuotaWarningType 额度预警类型
-	UserSettingQuotaWarningThreshold = "quota_warning_threshold"        // QuotaWarningThreshold 额度预警阈值
-	UserSettingWebhookUrl            = "webhook_url"                    // WebhookUrl webhook地址
-	UserSettingWebhookSecret         = "webhook_secret"                 // WebhookSecret webhook密钥
-	UserSettingNotificationEmail     = "notification_email"             // NotificationEmail 通知邮箱地址
-	UserAcceptUnsetRatioModel        = "accept_unset_model_ratio_model" // AcceptUnsetRatioModel 是否接受未设置价格的模型
-	UserSettingRecordIpLog          = "record_ip_log"                   // 是否记录请求和错误日志IP
-)
-
-var (
-	NotifyTypeEmail   = "email"   // Email 邮件
-	NotifyTypeWebhook = "webhook" // Webhook
-)
--- a/controller/billing.go
+++ b/controller/billing.go
@@ -21,7 +21,7 @@ func GetSubscription(c *gin.Context) {
 		usedQuota = token.UsedQuota
 	} else {
 		userId := c.GetInt("id")
-		remainQuota, err = model.GetUserQuota(userId, false)
+		remainQuota, err = model.GetUserQuota(userId)
 		usedQuota, err = model.GetUserUsedQuota(userId)
 	}
 	if expiredTime <= 0 {
--- a/controller/channel-billing.go
+++ b/controller/channel-billing.go
@@ -4,13 +4,11 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/shopspring/decimal"
 	"io"
 	"net/http"
 	"one-api/common"
 	"one-api/model"
 	"one-api/service"
-	"one-api/setting"
 	"strconv"
 	"time"

@@ -80,43 +78,6 @@ type APGC2DGPTUsageResponse struct {
 	TotalUsed      float64 `json:"total_used"`
 }

-type SiliconFlowUsageResponse struct {
-	Code    int    `json:"code"`
-	Message string `json:"message"`
-	Status  bool   `json:"status"`
-	Data    struct {
-		ID            string `json:"id"`
-		Name          string `json:"name"`
-		Image         string `json:"image"`
-		Email         string `json:"email"`
-		IsAdmin       bool   `json:"isAdmin"`
-		Balance       string `json:"balance"`
-		Status        string `json:"status"`
-		Introduction  string `json:"introduction"`
-		Role          string `json:"role"`
-		ChargeBalance string `json:"chargeBalance"`
-		TotalBalance  string `json:"totalBalance"`
-		Category      string `json:"category"`
-	} `json:"data"`
-}
-
-type DeepSeekUsageResponse struct {
-	IsAvailable  bool `json:"is_available"`
-	BalanceInfos []struct {
-		Currency        string `json:"currency"`
-		TotalBalance    string `json:"total_balance"`
-		GrantedBalance  string `json:"granted_balance"`
-		ToppedUpBalance string `json:"topped_up_balance"`
-	} `json:"balance_infos"`
-}
-
-type OpenRouterCreditResponse struct {
-	Data struct {
-		TotalCredits float64 `json:"total_credits"`
-		TotalUsage   float64 `json:"total_usage"`
-	} `json:"data"`
-}
-
 // GetAuthHeader get auth header
 func GetAuthHeader(token string) http.Header {
 	h := http.Header{}
@@ -224,57 +185,6 @@ func updateChannelAPI2GPTBalance(channel *model.Channel) (float64, error) {
 	return response.TotalRemaining, nil
 }

-func updateChannelSiliconFlowBalance(channel *model.Channel) (float64, error) {
-	url := "https://api.siliconflow.cn/v1/user/info"
-	body, err := GetResponseBody("GET", url, channel, GetAuthHeader(channel.Key))
-	if err != nil {
-		return 0, err
-	}
-	response := SiliconFlowUsageResponse{}
-	err = json.Unmarshal(body, &response)
-	if err != nil {
-		return 0, err
-	}
-	if response.Code != 20000 {
-		return 0, fmt.Errorf("code: %d, message: %s", response.Code, response.Message)
-	}
-	balance, err := strconv.ParseFloat(response.Data.TotalBalance, 64)
-	if err != nil {
-		return 0, err
-	}
-	channel.UpdateBalance(balance)
-	return balance, nil
-}
-
-func updateChannelDeepSeekBalance(channel *model.Channel) (float64, error) {
-	url := "https://api.deepseek.com/user/balance"
-	body, err := GetResponseBody("GET", url, channel, GetAuthHeader(channel.Key))
-	if err != nil {
-		return 0, err
-	}
-	response := DeepSeekUsageResponse{}
-	err = json.Unmarshal(body, &response)
-	if err != nil {
-		return 0, err
-	}
-	index := -1
-	for i, balanceInfo := range response.BalanceInfos {
-		if balanceInfo.Currency == "CNY" {
-			index = i
-			break
-		}
-	}
-	if index == -1 {
-		return 0, errors.New("currency CNY not found")
-	}
-	balance, err := strconv.ParseFloat(response.BalanceInfos[index].TotalBalance, 64)
-	if err != nil {
-		return 0, err
-	}
-	channel.UpdateBalance(balance)
-	return balance, nil
-}
-
 func updateChannelAIGC2DBalance(channel *model.Channel) (float64, error) {
 	url := "https://api.aigc2d.com/dashboard/billing/credit_grants"
 	body, err := GetResponseBody("GET", url, channel, GetAuthHeader(channel.Key))
@@ -290,56 +200,6 @@ func updateChannelAIGC2DBalance(channel *model.Channel) (float64, error) {
 	return response.TotalAvailable, nil
 }

-func updateChannelOpenRouterBalance(channel *model.Channel) (float64, error) {
-	url := "https://openrouter.ai/api/v1/credits"
-	body, err := GetResponseBody("GET", url, channel, GetAuthHeader(channel.Key))
-	if err != nil {
-		return 0, err
-	}
-	response := OpenRouterCreditResponse{}
-	err = json.Unmarshal(body, &response)
-	if err != nil {
-		return 0, err
-	}
-	balance := response.Data.TotalCredits - response.Data.TotalUsage
-	channel.UpdateBalance(balance)
-	return balance, nil
-}
-
-func updateChannelMoonshotBalance(channel *model.Channel) (float64, error) {
-	url := "https://api.moonshot.cn/v1/users/me/balance"
-	body, err := GetResponseBody("GET", url, channel, GetAuthHeader(channel.Key))
-	if err != nil {
-		return 0, err
-	}
-
-	type MoonshotBalanceData struct {
-		AvailableBalance float64 `json:"available_balance"`
-		VoucherBalance   float64 `json:"voucher_balance"`
-		CashBalance      float64 `json:"cash_balance"`
-	}
-
-	type MoonshotBalanceResponse struct {
-		Code   int                 `json:"code"`
-		Data   MoonshotBalanceData `json:"data"`
-		Scode  string              `json:"scode"`
-		Status bool                `json:"status"`
-	}
-
-	response := MoonshotBalanceResponse{}
-	err = json.Unmarshal(body, &response)
-	if err != nil {
-		return 0, err
-	}
-	if !response.Status || response.Code != 0 {
-		return 0, fmt.Errorf("failed to update moonshot balance, status: %v, code: %d, scode: %s", response.Status, response.Code, response.Scode)
-	}
-	availableBalanceCny := response.Data.AvailableBalance
-	availableBalanceUsd := decimal.NewFromFloat(availableBalanceCny).Div(decimal.NewFromFloat(setting.Price)).InexactFloat64()
-	channel.UpdateBalance(availableBalanceUsd)
-	return availableBalanceUsd, nil
-}
-
 func updateChannelBalance(channel *model.Channel) (float64, error) {
 	baseURL := common.ChannelBaseURLs[channel.Type]
 	if channel.GetBaseURL() == "" {
@@ -362,14 +222,6 @@ func updateChannelBalance(channel *model.Channel) (float64, error) {
 		return updateChannelAPI2GPTBalance(channel)
 	case common.ChannelTypeAIGC2D:
 		return updateChannelAIGC2DBalance(channel)
-	case common.ChannelTypeSiliconFlow:
-		return updateChannelSiliconFlowBalance(channel)
-	case common.ChannelTypeDeepSeek:
-		return updateChannelDeepSeekBalance(channel)
-	case common.ChannelTypeOpenRouter:
-		return updateChannelOpenRouterBalance(channel)
-	case common.ChannelTypeMoonshot:
-		return updateChannelMoonshotBalance(channel)
 	default:
 		return 0, errors.New("尚未实现")
 	}
@@ -448,9 +300,9 @@ func updateAllChannelsBalance() error {
 			continue
 		}
 		// TODO: support Azure
-		//if channel.Type != common.ChannelTypeOpenAI && channel.Type != common.ChannelTypeCustom {
-		//	continue
-		//}
+		if channel.Type != common.ChannelTypeOpenAI && channel.Type != common.ChannelTypeCustom {
+			continue
+		}
 		balance, err := updateChannelBalance(channel)
 		if err != nil {
 			continue
--- a/controller/channel-test.go
+++ b/controller/channel-test.go
@@ -6,119 +6,90 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"math"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
 	"one-api/common"
 	"one-api/dto"
-	"one-api/middleware"
 	"one-api/model"
 	"one-api/relay"
 	relaycommon "one-api/relay/common"
 	"one-api/relay/constant"
-	"one-api/relay/helper"
 	"one-api/service"
 	"strconv"
-	"strings"
 	"sync"
 	"time"

-	"github.com/bytedance/gopkg/util/gopool"
-
 	"github.com/gin-gonic/gin"
 )

-func testChannel(channel *model.Channel, testModel string) (err error, openAIErrorWithStatusCode *dto.OpenAIErrorWithStatusCode) {
-	tik := time.Now()
+func testChannel(channel *model.Channel, testModel string) (err error, openaiErr *dto.OpenAIError) {
 	if channel.Type == common.ChannelTypeMidjourney {
 		return errors.New("midjourney channel test is not supported"), nil
 	}
-	if channel.Type == common.ChannelTypeMidjourneyPlus {
-		return errors.New("midjourney plus channel test is not supported!!!"), nil
-	}
 	if channel.Type == common.ChannelTypeSunoAPI {
 		return errors.New("suno channel test is not supported"), nil
 	}
-	if channel.Type == common.ChannelTypeKling {
-		return errors.New("kling channel test is not supported"), nil
-	}
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
-
-	requestPath := "/v1/chat/completions"
-
-	// 先判断是否为 Embedding 模型
-	if strings.Contains(strings.ToLower(testModel), "embedding") ||
-		strings.HasPrefix(testModel, "m3e") || // m3e 系列模型
-		strings.Contains(testModel, "bge-") || // bge 系列模型
-		strings.Contains(testModel, "embed") ||
-		channel.Type == common.ChannelTypeMokaAI { // 其他 embedding 模型
-		requestPath = "/v1/embeddings" // 修改请求路径
-	}
-
 	c.Request = &http.Request{
 		Method: "POST",
-		URL:    &url.URL{Path: requestPath}, // 使用动态路径
+		URL:    &url.URL{Path: "/v1/chat/completions"},
 		Body:   nil,
 		Header: make(http.Header),
 	}
-
-	if testModel == "" {
-		if channel.TestModel != nil && *channel.TestModel != "" {
-			testModel = *channel.TestModel
-		} else {
-			if len(channel.GetModels()) > 0 {
-				testModel = channel.GetModels()[0]
-			} else {
-				testModel = "gpt-4o-mini"
-			}
-		}
-	}
-
-	cache, err := model.GetUserCache(1)
-	if err != nil {
-		return err, nil
-	}
-	cache.WriteContext(c)
-
 	c.Request.Header.Set("Authorization", "Bearer "+channel.Key)
 	c.Request.Header.Set("Content-Type", "application/json")
 	c.Set("channel", channel.Type)
 	c.Set("base_url", channel.GetBaseURL())
-	group, _ := model.GetUserGroup(1, false)
-	c.Set("group", group)
-
-	middleware.SetupContextForSelectedChannel(c, channel, testModel)
-
-	info := relaycommon.GenRelayInfo(c)
-
-	err = helper.ModelMappedHelper(c, info, nil)
-	if err != nil {
-		return err, nil
+	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)
 	}
-	testModel = info.UpstreamModelName

+	meta := relaycommon.GenRelayInfo(c)
 	apiType, _ := constant.ChannelType2APIType(channel.Type)
 	adaptor := relay.GetAdaptor(apiType)
 	if adaptor == nil {
 		return fmt.Errorf("invalid api type: %d, adaptor is nil", apiType), nil
 	}
-
-	request := buildTestRequest(testModel)
-	// 创建一个用于日志的 info 副本，移除 ApiKey
-	logInfo := *info
-	logInfo.ApiKey = ""
-	common.SysLog(fmt.Sprintf("testing channel %d with model %s , info %+v ", channel.Id, testModel, logInfo))
-
-	priceData, err := helper.ModelPriceHelper(c, info, 0, int(request.MaxTokens))
-	if err != nil {
-		return err, nil
+	if testModel == "" {
+		if channel.TestModel != nil && *channel.TestModel != "" {
+			testModel = *channel.TestModel
+		} else {
+			testModel = adaptor.GetModelList()[0]
+		}
+	} else {
+		modelMapping := *channel.ModelMapping
+		if modelMapping != "" && modelMapping != "{}" {
+			modelMap := make(map[string]string)
+			err := json.Unmarshal([]byte(modelMapping), &modelMap)
+			if err != nil {
+				openaiErr := service.OpenAIErrorWrapperLocal(err, "unmarshal_model_mapping_failed", http.StatusInternalServerError).Error
+				return err, &openaiErr
+			}
+			if modelMap[testModel] != "" {
+				testModel = modelMap[testModel]
+			}
+		}
 	}

-	adaptor.Init(info)
+	request := buildTestRequest()
+	request.Model = testModel
+	meta.UpstreamModelName = testModel
+	common.SysLog(fmt.Sprintf("testing channel %d with model %s", channel.Id, testModel))

-	convertedRequest, err := adaptor.ConvertOpenAIRequest(c, info, request)
+	adaptor.Init(meta, *request)
+
+	convertedRequest, err := adaptor.ConvertRequest(c, constant.RelayModeChatCompletions, request)
 	if err != nil {
 		return err, nil
 	}
@@ -128,93 +99,48 @@ func testChannel(channel *model.Channel, testModel string) (err error, openAIErr
 	}
 	requestBody := bytes.NewBuffer(jsonData)
 	c.Request.Body = io.NopCloser(requestBody)
-	resp, err := adaptor.DoRequest(c, info, requestBody)
+	resp, err := adaptor.DoRequest(c, meta, requestBody)
 	if err != nil {
 		return err, nil
 	}
-	var httpResp *http.Response
-	if resp != nil {
-		httpResp = resp.(*http.Response)
-		if httpResp.StatusCode != http.StatusOK {
-			err := service.RelayErrorHandler(httpResp, true)
-			return fmt.Errorf("status code %d: %s", httpResp.StatusCode, err.Error.Message), err
-		}
+	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
 	}
-	usageA, respErr := adaptor.DoResponse(c, httpResp, info)
+	usage, respErr := adaptor.DoResponse(c, resp, meta)
 	if respErr != nil {
-		return fmt.Errorf("%s", respErr.Error.Message), respErr
+		return fmt.Errorf("%s", respErr.Error.Message), &respErr.Error
 	}
-	if usageA == nil {
+	if usage == nil {
 		return errors.New("usage is nil"), nil
 	}
-	usage := usageA.(*dto.Usage)
 	result := w.Result()
+	// print result.Body
 	respBody, err := io.ReadAll(result.Body)
 	if err != nil {
 		return err, nil
 	}
-	info.PromptTokens = usage.PromptTokens
-
-	quota := 0
-	if !priceData.UsePrice {
-		quota = usage.PromptTokens + int(math.Round(float64(usage.CompletionTokens)*priceData.CompletionRatio))
-		quota = int(math.Round(float64(quota) * priceData.ModelRatio))
-		if priceData.ModelRatio != 0 && quota <= 0 {
-			quota = 1
-		}
-	} else {
-		quota = int(priceData.ModelPrice * common.QuotaPerUnit)
-	}
-	tok := time.Now()
-	milliseconds := tok.Sub(tik).Milliseconds()
-	consumedTime := float64(milliseconds) / 1000.0
-	other := service.GenerateTextOtherInfo(c, info, priceData.ModelRatio, priceData.GroupRatioInfo.GroupRatio, priceData.CompletionRatio,
-		usage.PromptTokensDetails.CachedTokens, priceData.CacheRatio, priceData.ModelPrice, priceData.GroupRatioInfo.GroupSpecialRatio)
-	model.RecordConsumeLog(c, 1, channel.Id, usage.PromptTokens, usage.CompletionTokens, info.OriginModelName, "模型测试",
-		quota, "模型测试", 0, quota, int(consumedTime), false, info.UsingGroup, other)
 	common.SysLog(fmt.Sprintf("testing channel #%d, response: \n%s", channel.Id, string(respBody)))
 	return nil, nil
 }

-func buildTestRequest(model string) *dto.GeneralOpenAIRequest {
+func buildTestRequest() *dto.GeneralOpenAIRequest {
 	testRequest := &dto.GeneralOpenAIRequest{
-		Model:  "", // this will be set later
-		Stream: false,
+		Model:     "", // this will be set later
+		MaxTokens: 1,
+		Stream:    false,
 	}
-
-	// 先判断是否为 Embedding 模型
-	if strings.Contains(strings.ToLower(model), "embedding") || // 其他 embedding 模型
-		strings.HasPrefix(model, "m3e") || // m3e 系列模型
-		strings.Contains(model, "bge-") {
-		testRequest.Model = model
-		// Embedding 请求
-		testRequest.Input = []string{"hello world"}
-		return testRequest
-	}
-	// 并非Embedding 模型
-	if strings.HasPrefix(model, "o") {
-		testRequest.MaxCompletionTokens = 10
-	} else if strings.Contains(model, "thinking") {
-		if !strings.Contains(model, "claude") {
-			testRequest.MaxTokens = 50
-		}
-	} else if strings.Contains(model, "gemini") {
-		testRequest.MaxTokens = 300
-	} else {
-		testRequest.MaxTokens = 10
-	}
-
+	content, _ := json.Marshal("hi")
 	testMessage := dto.Message{
 		Role:    "user",
-		Content: "hi",
+		Content: content,
 	}
-	testRequest.Model = model
 	testRequest.Messages = append(testRequest.Messages, testMessage)
 	return testRequest
 }

 func TestChannel(c *gin.Context) {
-	channelId, err := strconv.Atoi(c.Param("id"))
+	id, err := strconv.Atoi(c.Param("id"))
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
@@ -222,7 +148,7 @@ func TestChannel(c *gin.Context) {
 		})
 		return
 	}
-	channel, err := model.GetChannelById(channelId, true)
+	channel, err := model.GetChannelById(id, true)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
@@ -257,7 +183,9 @@ var testAllChannelsLock sync.Mutex
 var testAllChannelsRunning bool = false

 func testAllChannels(notify bool) error {
-
+	if common.RootUserEmail == "" {
+		common.RootUserEmail = model.GetRootUserEmail()
+	}
 	testAllChannelsLock.Lock()
 	if testAllChannelsRunning {
 		testAllChannelsLock.Unlock()
@@ -273,53 +201,46 @@ func testAllChannels(notify bool) error {
 	if disableThreshold == 0 {
 		disableThreshold = 10000000 // a impossible value
 	}
-	gopool.Go(func() {
-		// 使用 defer 确保无论如何都会重置运行状态，防止死锁
-		defer func() {
-			testAllChannelsLock.Lock()
-			testAllChannelsRunning = false
-			testAllChannelsLock.Unlock()
-		}()
-
+	go func() {
 		for _, channel := range channels {
 			isChannelEnabled := channel.Status == common.ChannelStatusEnabled
 			tik := time.Now()
-			err, openaiWithStatusErr := testChannel(channel, "")
+			err, openaiErr := testChannel(channel, "")
 			tok := time.Now()
 			milliseconds := tok.Sub(tik).Milliseconds()

-			shouldBanChannel := false
-
-			// request error disables the channel
-			if openaiWithStatusErr != nil {
-				oaiErr := openaiWithStatusErr.Error
-				err = errors.New(fmt.Sprintf("type %s, httpCode %d, code %v, message %s", oaiErr.Type, openaiWithStatusErr.StatusCode, oaiErr.Code, oaiErr.Message))
-				shouldBanChannel = service.ShouldDisableChannel(channel.Type, openaiWithStatusErr)
-			}
-
+			ban := false
 			if milliseconds > disableThreshold {
 				err = errors.New(fmt.Sprintf("响应时间 %.2fs 超过阈值 %.2fs", float64(milliseconds)/1000.0, float64(disableThreshold)/1000.0))
-				shouldBanChannel = true
+				ban = true
 			}
-
-			// disable channel
-			if isChannelEnabled && shouldBanChannel && channel.GetAutoBan() {
+			if openaiErr != nil {
+				err = errors.New(fmt.Sprintf("type %s, code %v, message %s", openaiErr.Type, openaiErr.Code, openaiErr.Message))
+				ban = true
+			}
+			// parse *int to bool
+			if channel.AutoBan != nil && *channel.AutoBan == 0 {
+				ban = false
+			}
+			if isChannelEnabled && service.ShouldDisableChannel(openaiErr, -1) && ban {
 				service.DisableChannel(channel.Id, channel.Name, err.Error())
 			}
-
-			// enable channel
-			if !isChannelEnabled && service.ShouldEnableChannel(err, openaiWithStatusErr, channel.Status) {
+			if !isChannelEnabled && service.ShouldEnableChannel(err, openaiErr, channel.Status) {
 				service.EnableChannel(channel.Id, channel.Name)
 			}
-
 			channel.UpdateResponseTime(milliseconds)
 			time.Sleep(common.RequestInterval)
 		}
-
+		testAllChannelsLock.Lock()
+		testAllChannelsRunning = false
+		testAllChannelsLock.Unlock()
 		if notify {
-			service.NotifyRootUser(dto.NotifyTypeChannelTest, "通道测试完成", "所有通道测试已完成")
+			err := common.SendEmail("通道测试完成", common.RootUserEmail, "通道测试完成，如果没有收到禁用通知，说明所有通道都正常")
+			if err != nil {
+				common.SysError(fmt.Sprintf("failed to send email: %s", err.Error()))
+			}
 		}
-	})
+	}()
 	return nil
 }

--- a/controller/channel.go
+++ b/controller/channel.go
@@ -3,13 +3,12 @@ package controller
 import (
 	"encoding/json"
 	"fmt"
+	"github.com/gin-gonic/gin"
 	"net/http"
 	"one-api/common"
 	"one-api/model"
 	"strconv"
 	"strings"
-
-	"github.com/gin-gonic/gin"
 )

 type OpenAIModel struct {
@@ -43,74 +42,25 @@ type OpenAIModelsResponse struct {
 func GetAllChannels(c *gin.Context) {
 	p, _ := strconv.Atoi(c.Query("p"))
 	pageSize, _ := strconv.Atoi(c.Query("page_size"))
-	if p < 1 {
-		p = 1
+	if p < 0 {
+		p = 0
 	}
-	if pageSize < 1 {
+	if pageSize < 0 {
 		pageSize = common.ItemsPerPage
 	}
-	channelData := make([]*model.Channel, 0)
 	idSort, _ := strconv.ParseBool(c.Query("id_sort"))
-	enableTagMode, _ := strconv.ParseBool(c.Query("tag_mode"))
-	// type filter
-	typeStr := c.Query("type")
-	typeFilter := -1
-	if typeStr != "" {
-		if t, err := strconv.Atoi(typeStr); err == nil {
-			typeFilter = t
-		}
+	channels, err := model.GetAllChannels(p*pageSize, pageSize, false, idSort)
+	if err != nil {
+		c.JSON(http.StatusOK, gin.H{
+			"success": false,
+			"message": err.Error(),
+		})
+		return
 	}
-
-	var total int64
-
-	if enableTagMode {
-		// tag 分页：先分页 tag，再取各 tag 下 channels
-		tags, err := model.GetPaginatedTags((p-1)*pageSize, pageSize)
-		if err != nil {
-			c.JSON(http.StatusOK, gin.H{"success": false, "message": err.Error()})
-			return
-		}
-		for _, tag := range tags {
-			if tag != nil && *tag != "" {
-				tagChannel, err := model.GetChannelsByTag(*tag, idSort)
-				if err == nil {
-					channelData = append(channelData, tagChannel...)
-				}
-			}
-		}
-		// 计算 tag 总数用于分页
-		total, _ = model.CountAllTags()
-	} else if typeFilter >= 0 {
-		channels, err := model.GetChannelsByType((p-1)*pageSize, pageSize, idSort, typeFilter)
-		if err != nil {
-			c.JSON(http.StatusOK, gin.H{"success": false, "message": err.Error()})
-			return
-		}
-		channelData = channels
-		total, _ = model.CountChannelsByType(typeFilter)
-	} else {
-		channels, err := model.GetAllChannels((p-1)*pageSize, pageSize, false, idSort)
-		if err != nil {
-			c.JSON(http.StatusOK, gin.H{"success": false, "message": err.Error()})
-			return
-		}
-		channelData = channels
-		total, _ = model.CountAllChannels()
-	}
-
-	// calculate type counts
-	typeCounts, _ := model.CountChannelsGroupByType()
-
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
 		"message": "",
-		"data": gin.H{
-			"items":       channelData,
-			"total":       total,
-			"page":        p,
-			"page_size":   pageSize,
-			"type_counts": typeCounts,
-		},
+		"data":    channels,
 	})
 	return
 }
@@ -124,7 +74,6 @@ func FetchUpstreamModels(c *gin.Context) {
 		})
 		return
 	}
-
 	channel, err := model.GetChannelById(id, true)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
@@ -133,43 +82,39 @@ func FetchUpstreamModels(c *gin.Context) {
 		})
 		return
 	}
-
-	baseURL := common.ChannelBaseURLs[channel.Type]
-	if channel.GetBaseURL() != "" {
-		baseURL = channel.GetBaseURL()
-	}
-	url := fmt.Sprintf("%s/v1/models", baseURL)
-	switch channel.Type {
-	case common.ChannelTypeGemini:
-		url = fmt.Sprintf("%s/v1beta/openai/models", baseURL)
-	case common.ChannelTypeAli:
-		url = fmt.Sprintf("%s/compatible-mode/v1/models", baseURL)
+	if channel.Type != common.ChannelTypeOpenAI {
+		c.JSON(http.StatusOK, gin.H{
+			"success": false,
+			"message": "仅支持 OpenAI 类型渠道",
+		})
+		return
 	}
+	url := fmt.Sprintf("%s/v1/models", *channel.BaseURL)
 	body, err := GetResponseBody("GET", url, channel, GetAuthHeader(channel.Key))
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
 			"message": err.Error(),
 		})
-		return
 	}
-
-	var result OpenAIModelsResponse
-	if err = json.Unmarshal(body, &result); err != nil {
+	result := OpenAIModelsResponse{}
+	err = json.Unmarshal(body, &result)
+	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
-			"message": fmt.Sprintf("解析响应失败: %s", err.Error()),
+			"message": err.Error(),
+		})
+	}
+	if !result.Success {
+		c.JSON(http.StatusOK, gin.H{
+			"success": false,
+			"message": "上游返回错误",
 		})
-		return
 	}

 	var ids []string
 	for _, model := range result.Data {
-		id := model.ID
-		if channel.Type == common.ChannelTypeGemini {
-			id = strings.TrimPrefix(id, "models/")
-		}
-		ids = append(ids, id)
+		ids = append(ids, model.ID)
 	}

 	c.JSON(http.StatusOK, gin.H{
@@ -199,51 +144,19 @@ func SearchChannels(c *gin.Context) {
 	keyword := c.Query("keyword")
 	group := c.Query("group")
 	modelKeyword := c.Query("model")
-	idSort, _ := strconv.ParseBool(c.Query("id_sort"))
-	enableTagMode, _ := strconv.ParseBool(c.Query("tag_mode"))
-	channelData := make([]*model.Channel, 0)
-	if enableTagMode {
-		tags, err := model.SearchTags(keyword, group, modelKeyword, idSort)
-		if err != nil {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": err.Error(),
-			})
-			return
-		}
-		for _, tag := range tags {
-			if tag != nil && *tag != "" {
-				tagChannel, err := model.GetChannelsByTag(*tag, idSort)
-				if err == nil {
-					channelData = append(channelData, tagChannel...)
-				}
-			}
-		}
-	} else {
-		channels, err := model.SearchChannels(keyword, group, modelKeyword, idSort)
-		if err != nil {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": err.Error(),
-			})
-			return
-		}
-		channelData = channels
+	//idSort, _ := strconv.ParseBool(c.Query("id_sort"))
+	channels, err := model.SearchChannels(keyword, group, modelKeyword)
+	if err != nil {
+		c.JSON(http.StatusOK, gin.H{
+			"success": false,
+			"message": err.Error(),
+		})
+		return
 	}
-
-	// calculate type counts for search results
-	typeCounts := make(map[int64]int64)
-	for _, channel := range channelData {
-		typeCounts[int64(channel.Type)]++
-	}
-
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
 		"message": "",
-		"data": gin.H{
-			"items":       channelData,
-			"type_counts": typeCounts,
-		},
+		"data":    channels,
 	})
 	return
 }
@@ -285,28 +198,6 @@ func AddChannel(c *gin.Context) {
 	}
 	channel.CreatedTime = common.GetTimestamp()
 	keys := strings.Split(channel.Key, "\n")
-	if channel.Type == common.ChannelTypeVertexAi {
-		if channel.Other == "" {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": "部署地区不能为空",
-			})
-			return
-		} else {
-			if common.IsJsonStr(channel.Other) {
-				// must have default
-				regionMap := common.StrToMap(channel.Other)
-				if regionMap["default"] == nil {
-					c.JSON(http.StatusOK, gin.H{
-						"success": false,
-						"message": "部署地区必须包含default字段",
-					})
-					return
-				}
-			}
-		}
-		keys = []string{channel.Key}
-	}
 	channels := make([]model.Channel, 0, len(keys))
 	for _, key := range keys {
 		if key == "" {
@@ -314,17 +205,6 @@ func AddChannel(c *gin.Context) {
 		}
 		localChannel := channel
 		localChannel.Key = key
-		// Validate the length of the model name
-		models := strings.Split(localChannel.Models, ",")
-		for _, model := range models {
-			if len(model) > 255 {
-				c.JSON(http.StatusOK, gin.H{
-					"success": false,
-					"message": fmt.Sprintf("模型名称过长: %s", model),
-				})
-				return
-			}
-		}
 		channels = append(channels, localChannel)
 	}
 	err = model.BatchInsertChannels(channels)
@@ -377,101 +257,8 @@ func DeleteDisabledChannel(c *gin.Context) {
 	return
 }

-type ChannelTag struct {
-	Tag          string  `json:"tag"`
-	NewTag       *string `json:"new_tag"`
-	Priority     *int64  `json:"priority"`
-	Weight       *uint   `json:"weight"`
-	ModelMapping *string `json:"model_mapping"`
-	Models       *string `json:"models"`
-	Groups       *string `json:"groups"`
-}
-
-func DisableTagChannels(c *gin.Context) {
-	channelTag := ChannelTag{}
-	err := c.ShouldBindJSON(&channelTag)
-	if err != nil || channelTag.Tag == "" {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": "参数错误",
-		})
-		return
-	}
-	err = model.DisableChannelByTag(channelTag.Tag)
-	if err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": err.Error(),
-		})
-		return
-	}
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"message": "",
-	})
-	return
-}
-
-func EnableTagChannels(c *gin.Context) {
-	channelTag := ChannelTag{}
-	err := c.ShouldBindJSON(&channelTag)
-	if err != nil || channelTag.Tag == "" {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": "参数错误",
-		})
-		return
-	}
-	err = model.EnableChannelByTag(channelTag.Tag)
-	if err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": err.Error(),
-		})
-		return
-	}
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"message": "",
-	})
-	return
-}
-
-func EditTagChannels(c *gin.Context) {
-	channelTag := ChannelTag{}
-	err := c.ShouldBindJSON(&channelTag)
-	if err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": "参数错误",
-		})
-		return
-	}
-	if channelTag.Tag == "" {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": "tag不能为空",
-		})
-		return
-	}
-	err = model.EditChannelByTag(channelTag.Tag, channelTag.NewTag, channelTag.ModelMapping, channelTag.Models, channelTag.Groups, channelTag.Priority, channelTag.Weight)
-	if err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": err.Error(),
-		})
-		return
-	}
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"message": "",
-	})
-	return
-}
-
 type ChannelBatch struct {
-	Ids []int   `json:"ids"`
-	Tag *string `json:"tag"`
+	Ids []int `json:"ids"`
 }

 func DeleteChannelBatch(c *gin.Context) {
@@ -510,27 +297,6 @@ func UpdateChannel(c *gin.Context) {
 		})
 		return
 	}
-	if channel.Type == common.ChannelTypeVertexAi {
-		if channel.Other == "" {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": "部署地区不能为空",
-			})
-			return
-		} else {
-			if common.IsJsonStr(channel.Other) {
-				// must have default
-				regionMap := common.StrToMap(channel.Other)
-				if regionMap["default"] == nil {
-					c.JSON(http.StatusOK, gin.H{
-						"success": false,
-						"message": "部署地区必须包含default字段",
-					})
-					return
-				}
-			}
-		}
-	}
 	err = channel.Update()
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
@@ -539,7 +305,6 @@ func UpdateChannel(c *gin.Context) {
 		})
 		return
 	}
-	channel.Key = ""
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
 		"message": "",
@@ -547,151 +312,3 @@ func UpdateChannel(c *gin.Context) {
 	})
 	return
 }
-
-func FetchModels(c *gin.Context) {
-	var req struct {
-		BaseURL string `json:"base_url"`
-		Type    int    `json:"type"`
-		Key     string `json:"key"`
-	}
-
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"success": false,
-			"message": "Invalid request",
-		})
-		return
-	}
-
-	baseURL := req.BaseURL
-	if baseURL == "" {
-		baseURL = common.ChannelBaseURLs[req.Type]
-	}
-
-	client := &http.Client{}
-	url := fmt.Sprintf("%s/v1/models", baseURL)
-
-	request, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"success": false,
-			"message": err.Error(),
-		})
-		return
-	}
-
-	// remove line breaks and extra spaces.
-	key := strings.TrimSpace(req.Key)
-	// If the key contains a line break, only take the first part.
-	key = strings.Split(key, "\n")[0]
-	request.Header.Set("Authorization", "Bearer "+key)
-
-	response, err := client.Do(request)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"success": false,
-			"message": err.Error(),
-		})
-		return
-	}
-	//check status code
-	if response.StatusCode != http.StatusOK {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"success": false,
-			"message": "Failed to fetch models",
-		})
-		return
-	}
-	defer response.Body.Close()
-
-	var result struct {
-		Data []struct {
-			ID string `json:"id"`
-		} `json:"data"`
-	}
-
-	if err := json.NewDecoder(response.Body).Decode(&result); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"success": false,
-			"message": err.Error(),
-		})
-		return
-	}
-
-	var models []string
-	for _, model := range result.Data {
-		models = append(models, model.ID)
-	}
-
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"data":    models,
-	})
-}
-
-func BatchSetChannelTag(c *gin.Context) {
-	channelBatch := ChannelBatch{}
-	err := c.ShouldBindJSON(&channelBatch)
-	if err != nil || len(channelBatch.Ids) == 0 {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": "参数错误",
-		})
-		return
-	}
-	err = model.BatchSetChannelTag(channelBatch.Ids, channelBatch.Tag)
-	if err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": err.Error(),
-		})
-		return
-	}
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"message": "",
-		"data":    len(channelBatch.Ids),
-	})
-	return
-}
-
-func GetTagModels(c *gin.Context) {
-	tag := c.Query("tag")
-	if tag == "" {
-		c.JSON(http.StatusBadRequest, gin.H{
-			"success": false,
-			"message": "tag不能为空",
-		})
-		return
-	}
-
-	channels, err := model.GetChannelsByTag(tag, false) // Assuming false for idSort is fine here
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"success": false,
-			"message": err.Error(),
-		})
-		return
-	}
-
-	var longestModels string
-	maxLength := 0
-
-	// Find the longest models string among all channels with the given tag
-	for _, channel := range channels {
-		if channel.Models != "" {
-			currentModels := strings.Split(channel.Models, ",")
-			if len(currentModels) > maxLength {
-				maxLength = len(currentModels)
-				longestModels = channel.Models
-			}
-		}
-	}
-
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"message": "",
-		"data":    longestModels,
-	})
-	return
-}
--- a/controller/console_migrate.go
+++ b/controller/console_migrate.go
@@ -1,103 +0,0 @@
-// 用于迁移检测的旧键，该文件下个版本会删除
-
-package controller
-
-import (
-    "encoding/json"
-    "net/http"
-    "one-api/common"
-    "one-api/model"
-    "github.com/gin-gonic/gin"
-)
-
-// MigrateConsoleSetting 迁移旧的控制台相关配置到 console_setting.*
-func MigrateConsoleSetting(c *gin.Context) {
-    // 读取全部 option
-    opts, err := model.AllOption()
-    if err != nil {
-        c.JSON(http.StatusInternalServerError, gin.H{"success": false, "message": err.Error()})
-        return
-    }
-    // 建立 map
-    valMap := map[string]string{}
-    for _, o := range opts {
-        valMap[o.Key] = o.Value
-    }
-
-    // 处理 APIInfo
-    if v := valMap["ApiInfo"]; v != "" {
-        var arr []map[string]interface{}
-        if err := json.Unmarshal([]byte(v), &arr); err == nil {
-            if len(arr) > 50 {
-                arr = arr[:50]
-            }
-            bytes, _ := json.Marshal(arr)
-            model.UpdateOption("console_setting.api_info", string(bytes))
-        }
-        model.UpdateOption("ApiInfo", "")
-    }
-    // Announcements 直接搬
-    if v := valMap["Announcements"]; v != "" {
-        model.UpdateOption("console_setting.announcements", v)
-        model.UpdateOption("Announcements", "")
-    }
-    // FAQ 转换
-    if v := valMap["FAQ"]; v != "" {
-        var arr []map[string]interface{}
-        if err := json.Unmarshal([]byte(v), &arr); err == nil {
-            out := []map[string]interface{}{}
-            for _, item := range arr {
-                q, _ := item["question"].(string)
-                if q == "" {
-                    q, _ = item["title"].(string)
-                }
-                a, _ := item["answer"].(string)
-                if a == "" {
-                    a, _ = item["content"].(string)
-                }
-                if q != "" && a != "" {
-                    out = append(out, map[string]interface{}{"question": q, "answer": a})
-                }
-            }
-            if len(out) > 50 {
-                out = out[:50]
-            }
-            bytes, _ := json.Marshal(out)
-            model.UpdateOption("console_setting.faq", string(bytes))
-        }
-        model.UpdateOption("FAQ", "")
-    }
-    // Uptime Kuma 迁移到新的 groups 结构（console_setting.uptime_kuma_groups）
-    url := valMap["UptimeKumaUrl"]
-    slug := valMap["UptimeKumaSlug"]
-    if url != "" && slug != "" {
-        // 仅当同时存在 URL 与 Slug 时才进行迁移
-        groups := []map[string]interface{}{
-            {
-                "id":           1,
-                "categoryName": "old",
-                "url":          url,
-                "slug":         slug,
-                "description":  "",
-            },
-        }
-        bytes, _ := json.Marshal(groups)
-        model.UpdateOption("console_setting.uptime_kuma_groups", string(bytes))
-    }
-    // 清空旧键内容
-    if url != "" {
-        model.UpdateOption("UptimeKumaUrl", "")
-    }
-    if slug != "" {
-        model.UpdateOption("UptimeKumaSlug", "")
-    }
-
-    // 删除旧键记录
-    oldKeys := []string{"ApiInfo", "Announcements", "FAQ", "UptimeKumaUrl", "UptimeKumaSlug"}
-    model.DB.Where("key IN ?", oldKeys).Delete(&model.Option{})
-
-    // 重新加载 OptionMap
-    model.InitOptionMap()
-    common.SysLog("console setting migrated")
-    c.JSON(http.StatusOK, gin.H{"success": true, "message": "migrated"})
-} 
--- a/controller/github.go
+++ b/controller/github.go
@@ -112,9 +112,7 @@ func GitHubOAuth(c *gin.Context) {
 	user := model.User{
 		GitHubId: githubUser.Login,
 	}
-	// IsGitHubIdAlreadyTaken is unscoped
 	if model.IsGitHubIdAlreadyTaken(user.GitHubId) {
-		// FillUserByGitHubId is scoped
 		err := user.FillUserByGitHubId()
 		if err != nil {
 			c.JSON(http.StatusOK, gin.H{
@@ -123,14 +121,6 @@ func GitHubOAuth(c *gin.Context) {
 			})
 			return
 		}
-		// if user.Id == 0 , user has been deleted
-		if user.Id == 0 {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": "用户已注销",
-			})
-			return
-		}
 	} else {
 		if common.RegisterEnabled {
 			user.Username = "github_" + strconv.Itoa(model.GetMaxUserId()+1)
@@ -142,13 +132,8 @@ func GitHubOAuth(c *gin.Context) {
 			user.Email = githubUser.Email
 			user.Role = common.RoleCommonUser
 			user.Status = common.UserStatusEnabled
-			affCode := session.Get("aff")
-			inviterId := 0
-			if affCode != nil {
-				inviterId, _ = model.GetUserIdByAffCode(affCode.(string))
-			}

-			if err := user.Insert(inviterId); err != nil {
+			if err := user.Insert(0); err != nil {
 				c.JSON(http.StatusOK, gin.H{
 					"success": false,
 					"message": err.Error(),
@@ -232,10 +217,6 @@ func GitHubBind(c *gin.Context) {
 func GenerateOAuthCode(c *gin.Context) {
 	session := sessions.Default(c)
 	state := common.GetRandomString(12)
-	affCode := c.Query("aff")
-	if affCode != "" {
-		session.Set("aff", affCode)
-	}
 	session.Set("oauth_state", state)
 	err := session.Save()
 	if err != nil {
--- a/controller/group.go
+++ b/controller/group.go
@@ -1,17 +1,14 @@
 package controller

 import (
-	"net/http"
-	"one-api/model"
-	"one-api/setting"
-	"one-api/setting/ratio_setting"
-
 	"github.com/gin-gonic/gin"
+	"net/http"
+	"one-api/common"
 )

 func GetGroups(c *gin.Context) {
 	groupNames := make([]string, 0)
-	for groupName := range ratio_setting.GetGroupRatioCopy() {
+	for groupName, _ := range common.GroupRatio {
 		groupNames = append(groupNames, groupName)
 	}
 	c.JSON(http.StatusOK, gin.H{
@@ -20,31 +17,3 @@ func GetGroups(c *gin.Context) {
 		"data":    groupNames,
 	})
 }
-
-func GetUserGroups(c *gin.Context) {
-	usableGroups := make(map[string]map[string]interface{})
-	userGroup := ""
-	userId := c.GetInt("id")
-	userGroup, _ = model.GetUserGroup(userId, false)
-	for groupName, ratio := range ratio_setting.GetGroupRatioCopy() {
-		// UserUsableGroups contains the groups that the user can use
-		userUsableGroups := setting.GetUserUsableGroups(userGroup)
-		if desc, ok := userUsableGroups[groupName]; ok {
-			usableGroups[groupName] = map[string]interface{}{
-				"ratio": ratio,
-				"desc":  desc,
-			}
-		}
-	}
-	if setting.GroupInUserUsableGroups("auto") {
-		usableGroups["auto"] = map[string]interface{}{
-			"ratio": "自动",
-			"desc":  setting.GetUsableGroupDescription("auto"),
-		}
-	}
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"message": "",
-		"data":    usableGroups,
-	})
-}
--- a/controller/image.go
+++ b/controller/image.go
@@ -1,9 +0,0 @@
-package controller
-
-import (
-	"github.com/gin-gonic/gin"
-)
-
-func GetImage(c *gin.Context) {
-
-}
--- a/controller/linuxdo.go
+++ b/controller/linuxdo.go
@@ -1,271 +0,0 @@
-package controller
-
-import (
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net/http"
-	"net/url"
-	"one-api/common"
-	"one-api/model"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/gin-contrib/sessions"
-	"github.com/gin-gonic/gin"
-)
-
-type LinuxdoUser struct {
-	Id         int    `json:"id"`
-	Username   string `json:"username"`
-	Name       string `json:"name"`
-	Active     bool   `json:"active"`
-	TrustLevel int    `json:"trust_level"`
-	Silenced   bool   `json:"silenced"`
-}
-
-func LinuxDoBind(c *gin.Context) {
-	if !common.LinuxDOOAuthEnabled {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": "管理员未开启通过 Linux DO 登录以及注册",
-		})
-		return
-	}
-
-	code := c.Query("code")
-	linuxdoUser, err := getLinuxdoUserInfoByCode(code, c)
-	if err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": err.Error(),
-		})
-		return
-	}
-
-	user := model.User{
-		LinuxDOId: strconv.Itoa(linuxdoUser.Id),
-	}
-
-	if model.IsLinuxDOIdAlreadyTaken(user.LinuxDOId) {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": "该 Linux DO 账户已被绑定",
-		})
-		return
-	}
-
-	session := sessions.Default(c)
-	id := session.Get("id")
-	user.Id = id.(int)
-
-	err = user.FillUserById()
-	if err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": err.Error(),
-		})
-		return
-	}
-
-	user.LinuxDOId = strconv.Itoa(linuxdoUser.Id)
-	err = user.Update(false)
-	if err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": err.Error(),
-		})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"message": "bind",
-	})
-}
-
-func getLinuxdoUserInfoByCode(code string, c *gin.Context) (*LinuxdoUser, error) {
-	if code == "" {
-		return nil, errors.New("invalid code")
-	}
-
-	// Get access token using Basic auth
-	tokenEndpoint := "https://connect.linux.do/oauth2/token"
-	credentials := common.LinuxDOClientId + ":" + common.LinuxDOClientSecret
-	basicAuth := "Basic " + base64.StdEncoding.EncodeToString([]byte(credentials))
-
-	// Get redirect URI from request
-	scheme := "http"
-	if c.Request.TLS != nil {
-		scheme = "https"
-	}
-	redirectURI := fmt.Sprintf("%s://%s/api/oauth/linuxdo", scheme, c.Request.Host)
-
-	data := url.Values{}
-	data.Set("grant_type", "authorization_code")
-	data.Set("code", code)
-	data.Set("redirect_uri", redirectURI)
-
-	req, err := http.NewRequest("POST", tokenEndpoint, strings.NewReader(data.Encode()))
-	if err != nil {
-		return nil, err
-	}
-
-	req.Header.Set("Authorization", basicAuth)
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	req.Header.Set("Accept", "application/json")
-
-	client := http.Client{Timeout: 5 * time.Second}
-	res, err := client.Do(req)
-	if err != nil {
-		return nil, errors.New("failed to connect to Linux DO server")
-	}
-	defer res.Body.Close()
-
-	var tokenRes struct {
-		AccessToken string `json:"access_token"`
-		Message     string `json:"message"`
-	}
-	if err := json.NewDecoder(res.Body).Decode(&tokenRes); err != nil {
-		return nil, err
-	}
-
-	if tokenRes.AccessToken == "" {
-		return nil, fmt.Errorf("failed to get access token: %s", tokenRes.Message)
-	}
-
-	// Get user info
-	userEndpoint := "https://connect.linux.do/api/user"
-	req, err = http.NewRequest("GET", userEndpoint, nil)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Authorization", "Bearer "+tokenRes.AccessToken)
-	req.Header.Set("Accept", "application/json")
-
-	res2, err := client.Do(req)
-	if err != nil {
-		return nil, errors.New("failed to get user info from Linux DO")
-	}
-	defer res2.Body.Close()
-
-	var linuxdoUser LinuxdoUser
-	if err := json.NewDecoder(res2.Body).Decode(&linuxdoUser); err != nil {
-		return nil, err
-	}
-
-	if linuxdoUser.Id == 0 {
-		return nil, errors.New("invalid user info returned")
-	}
-
-	return &linuxdoUser, nil
-}
-
-func LinuxdoOAuth(c *gin.Context) {
-	session := sessions.Default(c)
-
-	errorCode := c.Query("error")
-	if errorCode != "" {
-		errorDescription := c.Query("error_description")
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": errorDescription,
-		})
-		return
-	}
-
-	state := c.Query("state")
-	if state == "" || session.Get("oauth_state") == nil || state != session.Get("oauth_state").(string) {
-		c.JSON(http.StatusForbidden, gin.H{
-			"success": false,
-			"message": "state is empty or not same",
-		})
-		return
-	}
-
-	username := session.Get("username")
-	if username != nil {
-		LinuxDoBind(c)
-		return
-	}
-
-	if !common.LinuxDOOAuthEnabled {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": "管理员未开启通过 Linux DO 登录以及注册",
-		})
-		return
-	}
-
-	code := c.Query("code")
-	linuxdoUser, err := getLinuxdoUserInfoByCode(code, c)
-	if err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": err.Error(),
-		})
-		return
-	}
-
-	user := model.User{
-		LinuxDOId: strconv.Itoa(linuxdoUser.Id),
-	}
-
-	// Check if user exists
-	if model.IsLinuxDOIdAlreadyTaken(user.LinuxDOId) {
-		err := user.FillUserByLinuxDOId()
-		if err != nil {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": err.Error(),
-			})
-			return
-		}
-		if user.Id == 0 {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": "用户已注销",
-			})
-			return
-		}
-	} else {
-		if common.RegisterEnabled {
-			user.Username = "linuxdo_" + strconv.Itoa(model.GetMaxUserId()+1)
-			user.DisplayName = linuxdoUser.Name
-			user.Role = common.RoleCommonUser
-			user.Status = common.UserStatusEnabled
-
-			affCode := session.Get("aff")
-			inviterId := 0
-			if affCode != nil {
-				inviterId, _ = model.GetUserIdByAffCode(affCode.(string))
-			}
-
-			if err := user.Insert(inviterId); err != nil {
-				c.JSON(http.StatusOK, gin.H{
-					"success": false,
-					"message": err.Error(),
-				})
-				return
-			}
-		} else {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": "管理员关闭了新用户注册",
-			})
-			return
-		}
-	}
-
-	if user.Status != common.UserStatusEnabled {
-		c.JSON(http.StatusOK, gin.H{
-			"message": "用户已被封禁",
-			"success": false,
-		})
-		return
-	}
-
-	setupLogin(&user, c)
-}
--- a/controller/log.go
+++ b/controller/log.go
@@ -1,19 +1,18 @@
 package controller

 import (
+	"github.com/gin-gonic/gin"
 	"net/http"
 	"one-api/common"
 	"one-api/model"
 	"strconv"
-
-	"github.com/gin-gonic/gin"
 )

 func GetAllLogs(c *gin.Context) {
 	p, _ := strconv.Atoi(c.Query("p"))
 	pageSize, _ := strconv.Atoi(c.Query("page_size"))
-	if p < 1 {
-		p = 1
+	if p < 0 {
+		p = 0
 	}
 	if pageSize < 0 {
 		pageSize = common.ItemsPerPage
@@ -25,8 +24,7 @@ func GetAllLogs(c *gin.Context) {
 	tokenName := c.Query("token_name")
 	modelName := c.Query("model_name")
 	channel, _ := strconv.Atoi(c.Query("channel"))
-	group := c.Query("group")
-	logs, total, err := model.GetAllLogs(logType, startTimestamp, endTimestamp, modelName, username, tokenName, (p-1)*pageSize, pageSize, channel, group)
+	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,
@@ -37,20 +35,16 @@ func GetAllLogs(c *gin.Context) {
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
 		"message": "",
-		"data": map[string]any{
-			"items":     logs,
-			"total":     total,
-			"page":      p,
-			"page_size": pageSize,
-		},
+		"data":    logs,
 	})
+	return
 }

 func GetUserLogs(c *gin.Context) {
 	p, _ := strconv.Atoi(c.Query("p"))
 	pageSize, _ := strconv.Atoi(c.Query("page_size"))
-	if p < 1 {
-		p = 1
+	if p < 0 {
+		p = 0
 	}
 	if pageSize < 0 {
 		pageSize = common.ItemsPerPage
@@ -64,8 +58,7 @@ func GetUserLogs(c *gin.Context) {
 	endTimestamp, _ := strconv.ParseInt(c.Query("end_timestamp"), 10, 64)
 	tokenName := c.Query("token_name")
 	modelName := c.Query("model_name")
-	group := c.Query("group")
-	logs, total, err := model.GetUserLogs(userId, logType, startTimestamp, endTimestamp, modelName, tokenName, (p-1)*pageSize, pageSize, group)
+	logs, err := model.GetUserLogs(userId, logType, startTimestamp, endTimestamp, modelName, tokenName, p*pageSize, pageSize)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
@@ -76,12 +69,7 @@ func GetUserLogs(c *gin.Context) {
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
 		"message": "",
-		"data": map[string]any{
-			"items":     logs,
-			"total":     total,
-			"page":      p,
-			"page_size": pageSize,
-		},
+		"data":    logs,
 	})
 	return
 }
@@ -148,8 +136,7 @@ func GetLogsStat(c *gin.Context) {
 	username := c.Query("username")
 	modelName := c.Query("model_name")
 	channel, _ := strconv.Atoi(c.Query("channel"))
-	group := c.Query("group")
-	stat := model.SumUsedQuota(logType, startTimestamp, endTimestamp, modelName, username, tokenName, channel, group)
+	stat := model.SumUsedQuota(logType, startTimestamp, endTimestamp, modelName, username, tokenName, channel)
 	//tokenNum := model.SumUsedToken(logType, startTimestamp, endTimestamp, modelName, username, "")
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
@@ -171,8 +158,7 @@ func GetLogsSelfStat(c *gin.Context) {
 	tokenName := c.Query("token_name")
 	modelName := c.Query("model_name")
 	channel, _ := strconv.Atoi(c.Query("channel"))
-	group := c.Query("group")
-	quotaNum := model.SumUsedQuota(logType, startTimestamp, endTimestamp, modelName, username, tokenName, channel, group)
+	quotaNum := model.SumUsedQuota(logType, startTimestamp, endTimestamp, modelName, username, tokenName, channel)
 	//tokenNum := model.SumUsedToken(logType, startTimestamp, endTimestamp, modelName, username, tokenName)
 	c.JSON(200, gin.H{
 		"success": true,
@@ -196,7 +182,7 @@ func DeleteHistoryLogs(c *gin.Context) {
 		})
 		return
 	}
-	count, err := model.DeleteOldLog(c.Request.Context(), targetTimestamp, 100)
+	count, err := model.DeleteOldLog(targetTimestamp)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
--- a/controller/midjourney.go
+++ b/controller/midjourney.go
@@ -7,12 +7,13 @@ import (
 	"fmt"
 	"github.com/gin-gonic/gin"
 	"io"
+	"log"
 	"net/http"
 	"one-api/common"
+	"one-api/constant"
 	"one-api/dto"
 	"one-api/model"
 	"one-api/service"
-	"one-api/setting"
 	"strconv"
 	"time"
 )
@@ -145,26 +146,28 @@ func UpdateMidjourneyTaskBulk() {
 					buttonStr, _ := json.Marshal(responseItem.Buttons)
 					task.Buttons = string(buttonStr)
 				}
-				shouldReturnQuota := false
+
 				if (task.Progress != "100%" && responseItem.FailReason != "") || (task.Progress == "100%" && task.Status == "FAILURE") {
 					common.LogInfo(ctx, task.MjId+" 构建失败，"+task.FailReason)
 					task.Progress = "100%"
-					if task.Quota != 0 {
-						shouldReturnQuota = true
+					err = model.CacheUpdateUserQuota(task.UserId)
+					if err != nil {
+						common.LogError(ctx, "error update user quota cache: "+err.Error())
+					} else {
+						quota := task.Quota
+						if quota != 0 {
+							err = model.IncreaseUserQuota(task.UserId, quota)
+							if err != nil {
+								common.LogError(ctx, "fail to increase user quota: "+err.Error())
+							}
+							logContent := fmt.Sprintf("构图失败 %s，补偿 %s", task.MjId, common.LogQuota(quota))
+							model.RecordLog(task.UserId, model.LogTypeSystem, logContent)
+						}
 					}
 				}
 				err = task.Update()
 				if err != nil {
 					common.LogError(ctx, "UpdateMidjourneyTask task error: "+err.Error())
-				} else {
-					if shouldReturnQuota {
-						err = model.IncreaseUserQuota(task.UserId, task.Quota, false)
-						if err != nil {
-							common.LogError(ctx, "fail to increase user quota: "+err.Error())
-						}
-						logContent := fmt.Sprintf("构图失败 %s，补偿 %s", task.MjId, common.LogQuota(task.Quota))
-						model.RecordLog(task.UserId, model.LogTypeSystem, logContent)
-					}
 				}
 			}
 		}
@@ -214,12 +217,8 @@ func checkMjTaskNeedUpdate(oldTask *model.Midjourney, newTask dto.MidjourneyDto)

 func GetAllMidjourney(c *gin.Context) {
 	p, _ := strconv.Atoi(c.Query("p"))
-	if p < 1 {
-		p = 1
-	}
-	pageSize, _ := strconv.Atoi(c.Query("page_size"))
-	if pageSize <= 0 {
-		pageSize = common.ItemsPerPage
+	if p < 0 {
+		p = 0
 	}

 	// 解析其他查询参数
@@ -230,38 +229,31 @@ func GetAllMidjourney(c *gin.Context) {
 		EndTimestamp:   c.Query("end_timestamp"),
 	}

-	items := model.GetAllTasks((p-1)*pageSize, pageSize, queryParams)
-	total := model.CountAllTasks(queryParams)
-
-	if setting.MjForwardUrlEnabled {
-		for i, midjourney := range items {
-			midjourney.ImageUrl = setting.ServerAddress + "/mj/image/" + midjourney.MjId
-			items[i] = midjourney
+	logs := model.GetAllTasks(p*common.ItemsPerPage, common.ItemsPerPage, queryParams)
+	if logs == nil {
+		logs = make([]*model.Midjourney, 0)
+	}
+	if constant.MjForwardUrlEnabled {
+		for i, midjourney := range logs {
+			midjourney.ImageUrl = constant.ServerAddress + "/mj/image/" + midjourney.MjId
+			logs[i] = midjourney
 		}
 	}
 	c.JSON(200, gin.H{
 		"success": true,
 		"message": "",
-		"data": gin.H{
-			"items":     items,
-			"total":     total,
-			"page":      p,
-			"page_size": pageSize,
-		},
+		"data":    logs,
 	})
 }

 func GetUserMidjourney(c *gin.Context) {
 	p, _ := strconv.Atoi(c.Query("p"))
-	if p < 1 {
-		p = 1
-	}
-	pageSize, _ := strconv.Atoi(c.Query("page_size"))
-	if pageSize <= 0 {
-		pageSize = common.ItemsPerPage
+	if p < 0 {
+		p = 0
 	}

 	userId := c.GetInt("id")
+	log.Printf("userId = %d \n", userId)

 	queryParams := model.TaskQueryParams{
 		MjID:           c.Query("mj_id"),
@@ -269,23 +261,19 @@ func GetUserMidjourney(c *gin.Context) {
 		EndTimestamp:   c.Query("end_timestamp"),
 	}

-	items := model.GetAllUserTask(userId, (p-1)*pageSize, pageSize, queryParams)
-	total := model.CountAllUserTask(userId, queryParams)
-
-	if setting.MjForwardUrlEnabled {
-		for i, midjourney := range items {
-			midjourney.ImageUrl = setting.ServerAddress + "/mj/image/" + midjourney.MjId
-			items[i] = midjourney
+	logs := model.GetAllUserTask(userId, p*common.ItemsPerPage, common.ItemsPerPage, queryParams)
+	if logs == nil {
+		logs = make([]*model.Midjourney, 0)
+	}
+	if constant.MjForwardUrlEnabled {
+		for i, midjourney := range logs {
+			midjourney.ImageUrl = constant.ServerAddress + "/mj/image/" + midjourney.MjId
+			logs[i] = midjourney
 		}
 	}
 	c.JSON(200, gin.H{
 		"success": true,
 		"message": "",
-		"data": gin.H{
-			"items":     items,
-			"total":     total,
-			"page":      p,
-			"page_size": pageSize,
-		},
+		"data":    logs,
 	})
 }
--- a/controller/misc.go
+++ b/controller/misc.go
@@ -6,12 +6,7 @@ import (
 	"net/http"
 	"one-api/common"
 	"one-api/constant"
-	"one-api/middleware"
 	"one-api/model"
-	"one-api/setting"
-	"one-api/setting/console_setting"
-	"one-api/setting/operation_setting"
-	"one-api/setting/system_setting"
 	"strings"

 	"github.com/gin-gonic/gin"
@@ -26,85 +21,49 @@ func TestStatus(c *gin.Context) {
 		})
 		return
 	}
-	// 获取HTTP统计信息
-	httpStats := middleware.GetStats()
 	c.JSON(http.StatusOK, gin.H{
-		"success":    true,
-		"message":    "Server is running",
-		"http_stats": httpStats,
+		"success": true,
+		"message": "Server is running",
 	})
 	return
 }

 func GetStatus(c *gin.Context) {
-
-	cs := console_setting.GetConsoleSetting()
-
-	data := gin.H{
-		"version":                  common.Version,
-		"start_time":               common.StartTime,
-		"email_verification":       common.EmailVerificationEnabled,
-		"github_oauth":             common.GitHubOAuthEnabled,
-		"github_client_id":         common.GitHubClientId,
-		"linuxdo_oauth":            common.LinuxDOOAuthEnabled,
-		"linuxdo_client_id":        common.LinuxDOClientId,
-		"telegram_oauth":           common.TelegramOAuthEnabled,
-		"telegram_bot_name":        common.TelegramBotName,
-		"system_name":              common.SystemName,
-		"logo":                     common.Logo,
-		"footer_html":              common.Footer,
-		"wechat_qrcode":            common.WeChatAccountQRCodeImageURL,
-		"wechat_login":             common.WeChatAuthEnabled,
-		"server_address":           setting.ServerAddress,
-		"price":                    setting.Price,
-		"min_topup":                setting.MinTopUp,
-		"turnstile_check":          common.TurnstileCheckEnabled,
-		"turnstile_site_key":       common.TurnstileSiteKey,
-		"top_up_link":              common.TopUpLink,
-		"docs_link":                operation_setting.GetGeneralSetting().DocsLink,
-		"quota_per_unit":           common.QuotaPerUnit,
-		"display_in_currency":      common.DisplayInCurrencyEnabled,
-		"enable_batch_update":      common.BatchUpdateEnabled,
-		"enable_drawing":           common.DrawingEnabled,
-		"enable_task":              common.TaskEnabled,
-		"enable_data_export":       common.DataExportEnabled,
-		"data_export_default_time": common.DataExportDefaultTime,
-		"default_collapse_sidebar": common.DefaultCollapseSidebar,
-		"enable_online_topup":      setting.PayAddress != "" && setting.EpayId != "" && setting.EpayKey != "",
-		"mj_notify_enabled":        setting.MjNotifyEnabled,
-		"chats":                    setting.Chats,
-		"demo_site_enabled":        operation_setting.DemoSiteEnabled,
-		"self_use_mode_enabled":    operation_setting.SelfUseModeEnabled,
-		"default_use_auto_group":   setting.DefaultUseAutoGroup,
-		"pay_methods":              setting.PayMethods,
-
-		// 面板启用开关
-		"api_info_enabled":      cs.ApiInfoEnabled,
-		"uptime_kuma_enabled":   cs.UptimeKumaEnabled,
-		"announcements_enabled": cs.AnnouncementsEnabled,
-		"faq_enabled":           cs.FAQEnabled,
-
-		"oidc_enabled":                system_setting.GetOIDCSettings().Enabled,
-		"oidc_client_id":              system_setting.GetOIDCSettings().ClientId,
-		"oidc_authorization_endpoint": system_setting.GetOIDCSettings().AuthorizationEndpoint,
-		"setup":                       constant.Setup,
-	}
-
-	// 根据启用状态注入可选内容
-	if cs.ApiInfoEnabled {
-		data["api_info"] = console_setting.GetApiInfo()
-	}
-	if cs.AnnouncementsEnabled {
-		data["announcements"] = console_setting.GetAnnouncements()
-	}
-	if cs.FAQEnabled {
-		data["faq"] = console_setting.GetFAQ()
-	}
-
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
 		"message": "",
-		"data":    data,
+		"data": gin.H{
+			"version":                  common.Version,
+			"start_time":               common.StartTime,
+			"email_verification":       common.EmailVerificationEnabled,
+			"github_oauth":             common.GitHubOAuthEnabled,
+			"github_client_id":         common.GitHubClientId,
+			"telegram_oauth":           common.TelegramOAuthEnabled,
+			"telegram_bot_name":        common.TelegramBotName,
+			"system_name":              common.SystemName,
+			"logo":                     common.Logo,
+			"footer_html":              common.Footer,
+			"wechat_qrcode":            common.WeChatAccountQRCodeImageURL,
+			"wechat_login":             common.WeChatAuthEnabled,
+			"server_address":           constant.ServerAddress,
+			"price":                    constant.Price,
+			"min_topup":                constant.MinTopUp,
+			"turnstile_check":          common.TurnstileCheckEnabled,
+			"turnstile_site_key":       common.TurnstileSiteKey,
+			"top_up_link":              common.TopUpLink,
+			"chat_link":                common.ChatLink,
+			"chat_link2":               common.ChatLink2,
+			"quota_per_unit":           common.QuotaPerUnit,
+			"display_in_currency":      common.DisplayInCurrencyEnabled,
+			"enable_batch_update":      common.BatchUpdateEnabled,
+			"enable_drawing":           common.DrawingEnabled,
+			"enable_task":              common.TaskEnabled,
+			"enable_data_export":       common.DataExportEnabled,
+			"data_export_default_time": common.DataExportDefaultTime,
+			"default_collapse_sidebar": common.DefaultCollapseSidebar,
+			"enable_online_topup":      constant.PayAddress != "" && constant.EpayId != "" && constant.EpayKey != "",
+			"mj_notify_enabled":        constant.MjNotifyEnabled,
+		},
 	})
 	return
 }
@@ -245,7 +204,7 @@ func SendPasswordResetEmail(c *gin.Context) {
 	}
 	code := common.GenerateVerificationCode(0)
 	common.RegisterVerificationCodeWithKey(email, code, common.PasswordResetPurpose)
-	link := fmt.Sprintf("%s/user/reset?email=%s&token=%s", setting.ServerAddress, email, code)
+	link := fmt.Sprintf("%s/user/reset?email=%s&token=%s", constant.ServerAddress, email, code)
 	subject := fmt.Sprintf("%s密码重置", common.SystemName)
 	content := fmt.Sprintf("<p>您好，你正在进行%s密码重置。</p>"+
 		"<p>点击 <a href='%s'>此处</a> 进行密码重置。</p>"+
--- a/controller/model.go
+++ b/controller/model.go
@@ -2,7 +2,7 @@ package controller

 import (
 	"fmt"
-	"github.com/samber/lo"
+	"github.com/gin-gonic/gin"
 	"net/http"
 	"one-api/common"
 	"one-api/constant"
@@ -15,9 +15,6 @@ import (
 	"one-api/relay/channel/moonshot"
 	relaycommon "one-api/relay/common"
 	relayconstant "one-api/relay/constant"
-	"one-api/setting"
-
-	"github.com/gin-gonic/gin"
 )

 // https://platform.openai.com/docs/api-reference/models/list
@@ -134,84 +131,37 @@ func init() {
 		}
 		meta := &relaycommon.RelayInfo{ChannelType: i}
 		adaptor := relay.GetAdaptor(apiType)
-		adaptor.Init(meta)
+		adaptor.Init(meta, dto.GeneralOpenAIRequest{})
 		channelId2Models[i] = adaptor.GetModelList()
 	}
-	openAIModels = lo.UniqBy(openAIModels, func(m dto.OpenAIModels) string {
-		return m.Id
-	})
 }

 func ListModels(c *gin.Context) {
+	userId := c.GetInt("id")
+	user, err := model.GetUserById(userId, true)
+	if err != nil {
+		c.JSON(http.StatusOK, gin.H{
+			"success": false,
+			"message": err.Error(),
+		})
+		return
+	}
+	models := model.GetGroupModels(user.Group)
 	userOpenAiModels := make([]dto.OpenAIModels, 0)
 	permission := getPermission()
-
-	modelLimitEnable := c.GetBool("token_model_limit_enabled")
-	if modelLimitEnable {
-		s, ok := c.Get("token_model_limit")
-		var tokenModelLimit map[string]bool
-		if ok {
-			tokenModelLimit = s.(map[string]bool)
+	for _, s := range models {
+		if _, ok := openAIModelsMap[s]; ok {
+			userOpenAiModels = append(userOpenAiModels, openAIModelsMap[s])
 		} else {
-			tokenModelLimit = map[string]bool{}
-		}
-		for allowModel, _ := range tokenModelLimit {
-			if _, ok := openAIModelsMap[allowModel]; ok {
-				userOpenAiModels = append(userOpenAiModels, openAIModelsMap[allowModel])
-			} else {
-				userOpenAiModels = append(userOpenAiModels, dto.OpenAIModels{
-					Id:         allowModel,
-					Object:     "model",
-					Created:    1626777600,
-					OwnedBy:    "custom",
-					Permission: permission,
-					Root:       allowModel,
-					Parent:     nil,
-				})
-			}
-		}
-	} else {
-		userId := c.GetInt("id")
-		userGroup, err := model.GetUserGroup(userId, true)
-		if err != nil {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": "get user group failed",
+			userOpenAiModels = append(userOpenAiModels, dto.OpenAIModels{
+				Id:         s,
+				Object:     "model",
+				Created:    1626777600,
+				OwnedBy:    "custom",
+				Permission: permission,
+				Root:       s,
+				Parent:     nil,
 			})
-			return
-		}
-		group := userGroup
-		tokenGroup := c.GetString("token_group")
-		if tokenGroup != "" {
-			group = tokenGroup
-		}
-		var models []string
-		if tokenGroup == "auto" {
-			for _, autoGroup := range setting.AutoGroups {
-				groupModels := model.GetGroupModels(autoGroup)
-				for _, g := range groupModels {
-					if !common.StringsContains(models, g) {
-						models = append(models, g)
-					}
-				}
-			}
-		} else {
-			models = model.GetGroupModels(group)
-		}
-		for _, s := range models {
-			if _, ok := openAIModelsMap[s]; ok {
-				userOpenAiModels = append(userOpenAiModels, openAIModelsMap[s])
-			} else {
-				userOpenAiModels = append(userOpenAiModels, dto.OpenAIModels{
-					Id:         s,
-					Object:     "model",
-					Created:    1626777600,
-					OwnedBy:    "custom",
-					Permission: permission,
-					Root:       s,
-					Parent:     nil,
-				})
-			}
 		}
 	}
 	c.JSON(200, gin.H{
@@ -234,13 +184,6 @@ func DashboardListModels(c *gin.Context) {
 	})
 }

-func EnabledListModels(c *gin.Context) {
-	c.JSON(200, gin.H{
-		"success": true,
-		"data":    model.GetEnabledModels(),
-	})
-}
-
 func RetrieveModel(c *gin.Context) {
 	modelId := c.Param("model")
 	if aiModel, ok := openAIModelsMap[modelId]; ok {
--- a/controller/oidc.go
+++ b/controller/oidc.go
@@ -1,240 +0,0 @@
-package controller
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net/http"
-	"net/url"
-	"one-api/common"
-	"one-api/model"
-	"one-api/setting"
-	"one-api/setting/system_setting"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/gin-contrib/sessions"
-	"github.com/gin-gonic/gin"
-)
-
-type OidcResponse struct {
-	AccessToken  string `json:"access_token"`
-	IDToken      string `json:"id_token"`
-	RefreshToken string `json:"refresh_token"`
-	TokenType    string `json:"token_type"`
-	ExpiresIn    int    `json:"expires_in"`
-	Scope        string `json:"scope"`
-}
-
-type OidcUser struct {
-	OpenID            string `json:"sub"`
-	Email             string `json:"email"`
-	Name              string `json:"name"`
-	PreferredUsername string `json:"preferred_username"`
-	Picture           string `json:"picture"`
-}
-
-func getOidcUserInfoByCode(code string) (*OidcUser, error) {
-	if code == "" {
-		return nil, errors.New("无效的参数")
-	}
-
-	values := url.Values{}
-	values.Set("client_id", system_setting.GetOIDCSettings().ClientId)
-	values.Set("client_secret", system_setting.GetOIDCSettings().ClientSecret)
-	values.Set("code", code)
-	values.Set("grant_type", "authorization_code")
-	values.Set("redirect_uri", fmt.Sprintf("%s/oauth/oidc", setting.ServerAddress))
-	formData := values.Encode()
-	req, err := http.NewRequest("POST", system_setting.GetOIDCSettings().TokenEndpoint, strings.NewReader(formData))
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	req.Header.Set("Accept", "application/json")
-	client := http.Client{
-		Timeout: 5 * time.Second,
-	}
-	res, err := client.Do(req)
-	if err != nil {
-		common.SysLog(err.Error())
-		return nil, errors.New("无法连接至 OIDC 服务器，请稍后重试！")
-	}
-	defer res.Body.Close()
-	var oidcResponse OidcResponse
-	err = json.NewDecoder(res.Body).Decode(&oidcResponse)
-	if err != nil {
-		return nil, err
-	}
-
-	if oidcResponse.AccessToken == "" {
-		common.SysError("OIDC 获取 Token 失败，请检查设置！")
-		return nil, errors.New("OIDC 获取 Token 失败，请检查设置！")
-	}
-
-	req, err = http.NewRequest("GET", system_setting.GetOIDCSettings().UserInfoEndpoint, nil)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Authorization", "Bearer "+oidcResponse.AccessToken)
-	res2, err := client.Do(req)
-	if err != nil {
-		common.SysLog(err.Error())
-		return nil, errors.New("无法连接至 OIDC 服务器，请稍后重试！")
-	}
-	defer res2.Body.Close()
-	if res2.StatusCode != http.StatusOK {
-		common.SysError("OIDC 获取用户信息失败！请检查设置！")
-		return nil, errors.New("OIDC 获取用户信息失败！请检查设置！")
-	}
-
-	var oidcUser OidcUser
-	err = json.NewDecoder(res2.Body).Decode(&oidcUser)
-	if err != nil {
-		return nil, err
-	}
-	if oidcUser.OpenID == "" || oidcUser.Email == "" {
-		common.SysError("OIDC 获取用户信息为空！请检查设置！")
-		return nil, errors.New("OIDC 获取用户信息为空！请检查设置！")
-	}
-	return &oidcUser, nil
-}
-
-func OidcAuth(c *gin.Context) {
-	session := sessions.Default(c)
-	state := c.Query("state")
-	if state == "" || session.Get("oauth_state") == nil || state != session.Get("oauth_state").(string) {
-		c.JSON(http.StatusForbidden, gin.H{
-			"success": false,
-			"message": "state is empty or not same",
-		})
-		return
-	}
-	username := session.Get("username")
-	if username != nil {
-		OidcBind(c)
-		return
-	}
-	if !system_setting.GetOIDCSettings().Enabled {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": "管理员未开启通过 OIDC 登录以及注册",
-		})
-		return
-	}
-	code := c.Query("code")
-	oidcUser, err := getOidcUserInfoByCode(code)
-	if err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": err.Error(),
-		})
-		return
-	}
-	user := model.User{
-		OidcId: oidcUser.OpenID,
-	}
-	if model.IsOidcIdAlreadyTaken(user.OidcId) {
-		err := user.FillUserByOidcId()
-		if err != nil {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": err.Error(),
-			})
-			return
-		}
-	} else {
-		if common.RegisterEnabled {
-			user.Email = oidcUser.Email
-			if oidcUser.PreferredUsername != "" {
-				user.Username = oidcUser.PreferredUsername
-			} else {
-				user.Username = "oidc_" + strconv.Itoa(model.GetMaxUserId()+1)
-			}
-			if oidcUser.Name != "" {
-				user.DisplayName = oidcUser.Name
-			} else {
-				user.DisplayName = "OIDC User"
-			}
-			err := user.Insert(0)
-			if err != nil {
-				c.JSON(http.StatusOK, gin.H{
-					"success": false,
-					"message": err.Error(),
-				})
-				return
-			}
-		} else {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": "管理员关闭了新用户注册",
-			})
-			return
-		}
-	}
-
-	if user.Status != common.UserStatusEnabled {
-		c.JSON(http.StatusOK, gin.H{
-			"message": "用户已被封禁",
-			"success": false,
-		})
-		return
-	}
-	setupLogin(&user, c)
-}
-
-func OidcBind(c *gin.Context) {
-	if !system_setting.GetOIDCSettings().Enabled {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": "管理员未开启通过 OIDC 登录以及注册",
-		})
-		return
-	}
-	code := c.Query("code")
-	oidcUser, err := getOidcUserInfoByCode(code)
-	if err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": err.Error(),
-		})
-		return
-	}
-	user := model.User{
-		OidcId: oidcUser.OpenID,
-	}
-	if model.IsOidcIdAlreadyTaken(user.OidcId) {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": "该 OIDC 账户已被绑定",
-		})
-		return
-	}
-	session := sessions.Default(c)
-	id := session.Get("id")
-	// id := c.GetInt("id")  // critical bug!
-	user.Id = id.(int)
-	err = user.FillUserById()
-	if err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": err.Error(),
-		})
-		return
-	}
-	user.OidcId = oidcUser.OpenID
-	err = user.Update(false)
-	if err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": err.Error(),
-		})
-		return
-	}
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"message": "bind",
-	})
-	return
-}
--- a/controller/option.go
+++ b/controller/option.go
@@ -5,10 +5,6 @@ import (
 	"net/http"
 	"one-api/common"
 	"one-api/model"
-	"one-api/setting"
-	"one-api/setting/console_setting"
-	"one-api/setting/ratio_setting"
-	"one-api/setting/system_setting"
 	"strings"

 	"github.com/gin-gonic/gin"
@@ -54,22 +50,6 @@ func UpdateOption(c *gin.Context) {
 			})
 			return
 		}
-	case "oidc.enabled":
-		if option.Value == "true" && system_setting.GetOIDCSettings().ClientId == "" {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": "无法启用 OIDC 登录，请先填入 OIDC Client Id 以及 OIDC Client Secret！",
-			})
-			return
-		}
-	case "LinuxDOOAuthEnabled":
-		if option.Value == "true" && common.LinuxDOClientId == "" {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": "无法启用 LinuxDO OAuth，请先填入 LinuxDO Client Id 以及 LinuxDO Client Secret！",
-			})
-			return
-		}
 	case "EmailDomainRestrictionEnabled":
 		if option.Value == "true" && len(common.EmailDomainWhitelist) == 0 {
 			c.JSON(http.StatusOK, gin.H{
@@ -92,69 +72,6 @@ func UpdateOption(c *gin.Context) {
 				"success": false,
 				"message": "无法启用 Turnstile 校验，请先填入 Turnstile 校验相关配置信息！",
 			})
-
-			return
-		}
-	case "TelegramOAuthEnabled":
-		if option.Value == "true" && common.TelegramBotToken == "" {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": "无法启用 Telegram OAuth，请先填入 Telegram Bot Token！",
-			})
-			return
-		}
-	case "GroupRatio":
-		err = ratio_setting.CheckGroupRatio(option.Value)
-		if err != nil {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": err.Error(),
-			})
-			return
-		}
-	case "ModelRequestRateLimitGroup":
-		err = setting.CheckModelRequestRateLimitGroup(option.Value)
-		if err != nil {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": err.Error(),
-			})
-			return
-		}
-	case "console_setting.api_info":
-		err = console_setting.ValidateConsoleSettings(option.Value, "ApiInfo")
-		if err != nil {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": err.Error(),
-			})
-			return
-		}
-	case "console_setting.announcements":
-		err = console_setting.ValidateConsoleSettings(option.Value, "Announcements")
-		if err != nil {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": err.Error(),
-			})
-			return
-		}
-	case "console_setting.faq":
-		err = console_setting.ValidateConsoleSettings(option.Value, "FAQ")
-		if err != nil {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": err.Error(),
-			})
-			return
-		}
-	case "console_setting.uptime_kuma_groups":
-		err = console_setting.ValidateConsoleSettings(option.Value, "UptimeKumaGroups")
-		if err != nil {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": err.Error(),
-			})
 			return
 		}
 	}
--- a/controller/playground.go
+++ b/controller/playground.go
@@ -1,79 +0,0 @@
-package controller
-
-import (
-	"errors"
-	"fmt"
-	"net/http"
-	"one-api/common"
-	"one-api/constant"
-	"one-api/dto"
-	"one-api/middleware"
-	"one-api/model"
-	"one-api/service"
-	"one-api/setting"
-	"time"
-
-	"github.com/gin-gonic/gin"
-)
-
-func Playground(c *gin.Context) {
-	var openaiErr *dto.OpenAIErrorWithStatusCode
-
-	defer func() {
-		if openaiErr != nil {
-			c.JSON(openaiErr.StatusCode, gin.H{
-				"error": openaiErr.Error,
-			})
-		}
-	}()
-
-	useAccessToken := c.GetBool("use_access_token")
-	if useAccessToken {
-		openaiErr = service.OpenAIErrorWrapperLocal(errors.New("暂不支持使用 access token"), "access_token_not_supported", http.StatusBadRequest)
-		return
-	}
-
-	playgroundRequest := &dto.PlayGroundRequest{}
-	err := common.UnmarshalBodyReusable(c, playgroundRequest)
-	if err != nil {
-		openaiErr = service.OpenAIErrorWrapperLocal(err, "unmarshal_request_failed", http.StatusBadRequest)
-		return
-	}
-
-	if playgroundRequest.Model == "" {
-		openaiErr = service.OpenAIErrorWrapperLocal(errors.New("请选择模型"), "model_required", http.StatusBadRequest)
-		return
-	}
-	c.Set("original_model", playgroundRequest.Model)
-	group := playgroundRequest.Group
-	userGroup := c.GetString("group")
-
-	if group == "" {
-		group = userGroup
-	} else {
-		if !setting.GroupInUserUsableGroups(group) && group != userGroup {
-			openaiErr = service.OpenAIErrorWrapperLocal(errors.New("无权访问该分组"), "group_not_allowed", http.StatusForbidden)
-			return
-		}
-		c.Set("group", group)
-	}
-	c.Set("token_name", "playground-"+group)
-	channel, finalGroup, err := model.CacheGetRandomSatisfiedChannel(c, group, playgroundRequest.Model, 0)
-	if err != nil {
-		message := fmt.Sprintf("当前分组 %s 下对于模型 %s 无可用渠道", finalGroup, playgroundRequest.Model)
-		openaiErr = service.OpenAIErrorWrapperLocal(errors.New(message), "get_playground_channel_failed", http.StatusInternalServerError)
-		return
-	}
-	middleware.SetupContextForSelectedChannel(c, channel, playgroundRequest.Model)
-	c.Set(constant.ContextKeyRequestStartTime, time.Now())
-
-	// Write user context to ensure acceptUnsetRatio is available
-	userId := c.GetInt("id")
-	userCache, err := model.GetUserCache(userId)
-	if err != nil {
-		openaiErr = service.OpenAIErrorWrapperLocal(err, "get_user_cache_failed", http.StatusInternalServerError)
-		return
-	}
-	userCache.WriteContext(c)
-	Relay(c)
-}
--- a/controller/pricing.go
+++ b/controller/pricing.go
@@ -1,53 +1,29 @@
 package controller

 import (
-	"one-api/model"
-	"one-api/setting"
-	"one-api/setting/ratio_setting"
-
 	"github.com/gin-gonic/gin"
+	"one-api/common"
+	"one-api/model"
 )

 func GetPricing(c *gin.Context) {
-	pricing := model.GetPricing()
-	userId, exists := c.Get("id")
-	usableGroup := map[string]string{}
-	groupRatio := map[string]float64{}
-	for s, f := range ratio_setting.GetGroupRatioCopy() {
-		groupRatio[s] = f
+	userId := c.GetInt("id")
+	// if no login, get default group ratio
+	groupRatio := common.GetGroupRatio("default")
+	group, err := model.CacheGetUserGroup(userId)
+	if err == nil {
+		groupRatio = common.GetGroupRatio(group)
 	}
-	var group string
-	if exists {
-		user, err := model.GetUserCache(userId.(int))
-		if err == nil {
-			group = user.Group
-			for g := range groupRatio {
-				ratio, ok := ratio_setting.GetGroupGroupRatio(group, g)
-				if ok {
-					groupRatio[g] = ratio
-				}
-			}
-		}
-	}
-
-	usableGroup = setting.GetUserUsableGroups(group)
-	// check groupRatio contains usableGroup
-	for group := range ratio_setting.GetGroupRatioCopy() {
-		if _, ok := usableGroup[group]; !ok {
-			delete(groupRatio, group)
-		}
-	}
-
+	pricing := model.GetPricing(group)
 	c.JSON(200, gin.H{
-		"success":      true,
-		"data":         pricing,
-		"group_ratio":  groupRatio,
-		"usable_group": usableGroup,
+		"success":     true,
+		"data":        pricing,
+		"group_ratio": groupRatio,
 	})
 }

 func ResetModelRatio(c *gin.Context) {
-	defaultStr := ratio_setting.DefaultModelRatio2JSONString()
+	defaultStr := common.DefaultModelRatio2JSONString()
 	err := model.UpdateOption("ModelRatio", defaultStr)
 	if err != nil {
 		c.JSON(200, gin.H{
@@ -56,7 +32,7 @@ func ResetModelRatio(c *gin.Context) {
 		})
 		return
 	}
-	err = ratio_setting.UpdateModelRatioByJSONString(defaultStr)
+	err = common.UpdateModelRatioByJSONString(defaultStr)
 	if err != nil {
 		c.JSON(200, gin.H{
 			"success": false,
--- a/controller/ratio_config.go
+++ b/controller/ratio_config.go
@@ -1,24 +0,0 @@
-package controller
-
-import (
-    "net/http"
-    "one-api/setting/ratio_setting"
-
-    "github.com/gin-gonic/gin"
-)
-
-func GetRatioConfig(c *gin.Context) {
-    if !ratio_setting.IsExposeRatioEnabled() {
-        c.JSON(http.StatusForbidden, gin.H{
-            "success": false,
-            "message": "倍率配置接口未启用",
-        })
-        return
-    }
-
-    c.JSON(http.StatusOK, gin.H{
-        "success": true,
-        "message": "",
-        "data":    ratio_setting.GetExposedData(),
-    })
-} 
--- a/controller/ratio_sync.go
+++ b/controller/ratio_sync.go
@@ -1,474 +0,0 @@
-package controller
-
-import (
-    "context"
-    "encoding/json"
-    "fmt"
-    "net/http"
-    "strings"
-    "sync"
-    "time"
-
-    "one-api/common"
-    "one-api/dto"
-    "one-api/model"
-    "one-api/setting/ratio_setting"
-
-    "github.com/gin-gonic/gin"
-)
-
-const (
-    defaultTimeoutSeconds  = 10
-    defaultEndpoint        = "/api/ratio_config"
-    maxConcurrentFetches   = 8
-)
-
-var ratioTypes = []string{"model_ratio", "completion_ratio", "cache_ratio", "model_price"}
-
-type upstreamResult struct {
-    Name string                 `json:"name"`
-    Data map[string]any         `json:"data,omitempty"`
-    Err  string                 `json:"err,omitempty"`
-}
-
-func FetchUpstreamRatios(c *gin.Context) {
-    var req dto.UpstreamRequest
-    if err := c.ShouldBindJSON(&req); err != nil {
-        c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": err.Error()})
-        return
-    }
-
-    if req.Timeout <= 0 {
-        req.Timeout = defaultTimeoutSeconds
-    }
-
-    var upstreams []dto.UpstreamDTO
-
-    if len(req.Upstreams) > 0 {
-        for _, u := range req.Upstreams {
-            if strings.HasPrefix(u.BaseURL, "http") {
-                if u.Endpoint == "" {
-                    u.Endpoint = defaultEndpoint
-                }
-                u.BaseURL = strings.TrimRight(u.BaseURL, "/")
-                upstreams = append(upstreams, u)
-            }
-        }
-    } else if len(req.ChannelIDs) > 0 {
-        intIds := make([]int, 0, len(req.ChannelIDs))
-        for _, id64 := range req.ChannelIDs {
-            intIds = append(intIds, int(id64))
-        }
-        dbChannels, err := model.GetChannelsByIds(intIds)
-        if err != nil {
-            common.LogError(c.Request.Context(), "failed to query channels: "+err.Error())
-            c.JSON(http.StatusInternalServerError, gin.H{"success": false, "message": "查询渠道失败"})
-            return
-        }
-        for _, ch := range dbChannels {
-            if base := ch.GetBaseURL(); strings.HasPrefix(base, "http") {
-                upstreams = append(upstreams, dto.UpstreamDTO{
-                    ID:       ch.Id,
-                    Name:     ch.Name,
-                    BaseURL:  strings.TrimRight(base, "/"),
-                    Endpoint: "",
-                })
-            }
-        }
-    }
-
-    if len(upstreams) == 0 {
-        c.JSON(http.StatusOK, gin.H{"success": false, "message": "无有效上游渠道"})
-        return
-    }
-
-    var wg sync.WaitGroup
-    ch := make(chan upstreamResult, len(upstreams))
-
-    sem := make(chan struct{}, maxConcurrentFetches)
-
-    client := &http.Client{Transport: &http.Transport{MaxIdleConns: 100, IdleConnTimeout: 90 * time.Second, TLSHandshakeTimeout: 10 * time.Second, ExpectContinueTimeout: 1 * time.Second}}
-
-    for _, chn := range upstreams {
-        wg.Add(1)
-        go func(chItem dto.UpstreamDTO) {
-            defer wg.Done()
-
-            sem <- struct{}{}
-            defer func() { <-sem }()
-
-            endpoint := chItem.Endpoint
-            if endpoint == "" {
-                endpoint = defaultEndpoint
-            } else if !strings.HasPrefix(endpoint, "/") {
-                endpoint = "/" + endpoint
-            }
-            fullURL := chItem.BaseURL + endpoint
-
-            uniqueName := chItem.Name
-            if chItem.ID != 0 {
-                uniqueName = fmt.Sprintf("%s(%d)", chItem.Name, chItem.ID)
-            }
-
-            ctx, cancel := context.WithTimeout(c.Request.Context(), time.Duration(req.Timeout)*time.Second)
-            defer cancel()
-
-            httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, fullURL, nil)
-            if err != nil {
-                common.LogWarn(c.Request.Context(), "build request failed: "+err.Error())
-                ch <- upstreamResult{Name: uniqueName, Err: err.Error()}
-                return
-            }
-
-            resp, err := client.Do(httpReq)
-            if err != nil {
-                common.LogWarn(c.Request.Context(), "http error on "+chItem.Name+": "+err.Error())
-                ch <- upstreamResult{Name: uniqueName, Err: err.Error()}
-                return
-            }
-            defer resp.Body.Close()
-            if resp.StatusCode != http.StatusOK {
-                common.LogWarn(c.Request.Context(), "non-200 from "+chItem.Name+": "+resp.Status)
-                ch <- upstreamResult{Name: uniqueName, Err: resp.Status}
-                return
-            }
-            // 兼容两种上游接口格式：
-            //  type1: /api/ratio_config -> data 为 map[string]any，包含 model_ratio/completion_ratio/cache_ratio/model_price
-            //  type2: /api/pricing      -> data 为 []Pricing 列表，需要转换为与 type1 相同的 map 格式
-            var body struct {
-                Success bool            `json:"success"`
-                Data    json.RawMessage `json:"data"`
-                Message string          `json:"message"`
-            }
-
-            if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
-                common.LogWarn(c.Request.Context(), "json decode failed from "+chItem.Name+": "+err.Error())
-                ch <- upstreamResult{Name: uniqueName, Err: err.Error()}
-                return
-            }
-
-            if !body.Success {
-                ch <- upstreamResult{Name: uniqueName, Err: body.Message}
-                return
-            }
-
-            // 尝试按 type1 解析
-            var type1Data map[string]any
-            if err := json.Unmarshal(body.Data, &type1Data); err == nil {
-                // 如果包含至少一个 ratioTypes 字段，则认为是 type1
-                isType1 := false
-                for _, rt := range ratioTypes {
-                    if _, ok := type1Data[rt]; ok {
-                        isType1 = true
-                        break
-                    }
-                }
-                if isType1 {
-                    ch <- upstreamResult{Name: uniqueName, Data: type1Data}
-                    return
-                }
-            }
-
-            // 如果不是 type1，则尝试按 type2 (/api/pricing) 解析
-            var pricingItems []struct {
-                ModelName       string  `json:"model_name"`
-                QuotaType       int     `json:"quota_type"`
-                ModelRatio      float64 `json:"model_ratio"`
-                ModelPrice      float64 `json:"model_price"`
-                CompletionRatio float64 `json:"completion_ratio"`
-            }
-            if err := json.Unmarshal(body.Data, &pricingItems); err != nil {
-                common.LogWarn(c.Request.Context(), "unrecognized data format from "+chItem.Name+": "+err.Error())
-                ch <- upstreamResult{Name: uniqueName, Err: "无法解析上游返回数据"}
-                return
-            }
-
-            modelRatioMap := make(map[string]float64)
-            completionRatioMap := make(map[string]float64)
-            modelPriceMap := make(map[string]float64)
-
-            for _, item := range pricingItems {
-                if item.QuotaType == 1 {
-                    modelPriceMap[item.ModelName] = item.ModelPrice
-                } else {
-                    modelRatioMap[item.ModelName] = item.ModelRatio
-                    // completionRatio 可能为 0，此时也直接赋值，保持与上游一致
-                    completionRatioMap[item.ModelName] = item.CompletionRatio
-                }
-            }
-
-            converted := make(map[string]any)
-
-            if len(modelRatioMap) > 0 {
-                ratioAny := make(map[string]any, len(modelRatioMap))
-                for k, v := range modelRatioMap {
-                    ratioAny[k] = v
-                }
-                converted["model_ratio"] = ratioAny
-            }
-
-            if len(completionRatioMap) > 0 {
-                compAny := make(map[string]any, len(completionRatioMap))
-                for k, v := range completionRatioMap {
-                    compAny[k] = v
-                }
-                converted["completion_ratio"] = compAny
-            }
-
-            if len(modelPriceMap) > 0 {
-                priceAny := make(map[string]any, len(modelPriceMap))
-                for k, v := range modelPriceMap {
-                    priceAny[k] = v
-                }
-                converted["model_price"] = priceAny
-            }
-
-            ch <- upstreamResult{Name: uniqueName, Data: converted}
-        }(chn)
-    }
-
-    wg.Wait()
-    close(ch)
-
-    localData := ratio_setting.GetExposedData()
-
-    var testResults []dto.TestResult
-    var successfulChannels []struct {
-        name string
-        data map[string]any
-    }
-
-    for r := range ch {
-        if r.Err != "" {
-            testResults = append(testResults, dto.TestResult{
-                Name:   r.Name,
-                Status: "error",
-                Error:  r.Err,
-            })
-        } else {
-            testResults = append(testResults, dto.TestResult{
-                Name:   r.Name,
-                Status: "success",
-            })
-            successfulChannels = append(successfulChannels, struct {
-                name string
-                data map[string]any
-            }{name: r.Name, data: r.Data})
-        }
-    }
-
-    differences := buildDifferences(localData, successfulChannels)
-
-    c.JSON(http.StatusOK, gin.H{
-        "success": true,
-        "data": gin.H{
-            "differences":  differences,
-            "test_results": testResults,
-        },
-    })
-}
-
-func buildDifferences(localData map[string]any, successfulChannels []struct {
-    name string
-    data map[string]any
-}) map[string]map[string]dto.DifferenceItem {
-    differences := make(map[string]map[string]dto.DifferenceItem)
-
-    allModels := make(map[string]struct{})
-    
-    for _, ratioType := range ratioTypes {
-        if localRatioAny, ok := localData[ratioType]; ok {
-            if localRatio, ok := localRatioAny.(map[string]float64); ok {
-                for modelName := range localRatio {
-                    allModels[modelName] = struct{}{}
-                }
-            }
-        }
-    }
-    
-    for _, channel := range successfulChannels {
-        for _, ratioType := range ratioTypes {
-            if upstreamRatio, ok := channel.data[ratioType].(map[string]any); ok {
-                for modelName := range upstreamRatio {
-                    allModels[modelName] = struct{}{}
-                }
-            }
-        }
-    }
-
-    confidenceMap := make(map[string]map[string]bool)
-    
-    // 预处理阶段：检查pricing接口的可信度
-    for _, channel := range successfulChannels {
-        confidenceMap[channel.name] = make(map[string]bool)
-        
-        modelRatios, hasModelRatio := channel.data["model_ratio"].(map[string]any)
-        completionRatios, hasCompletionRatio := channel.data["completion_ratio"].(map[string]any)
-        
-        if hasModelRatio && hasCompletionRatio {
-            // 遍历所有模型，检查是否满足不可信条件
-            for modelName := range allModels {
-                // 默认为可信
-                confidenceMap[channel.name][modelName] = true
-                
-                // 检查是否满足不可信条件：model_ratio为37.5且completion_ratio为1
-                if modelRatioVal, ok := modelRatios[modelName]; ok {
-                    if completionRatioVal, ok := completionRatios[modelName]; ok {
-                        // 转换为float64进行比较
-                        if modelRatioFloat, ok := modelRatioVal.(float64); ok {
-                            if completionRatioFloat, ok := completionRatioVal.(float64); ok {
-                                if modelRatioFloat == 37.5 && completionRatioFloat == 1.0 {
-                                    confidenceMap[channel.name][modelName] = false
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        } else {
-            // 如果不是从pricing接口获取的数据，则全部标记为可信
-            for modelName := range allModels {
-                confidenceMap[channel.name][modelName] = true
-            }
-        }
-    }
-
-    for modelName := range allModels {
-        for _, ratioType := range ratioTypes {
-            var localValue interface{} = nil
-            if localRatioAny, ok := localData[ratioType]; ok {
-                if localRatio, ok := localRatioAny.(map[string]float64); ok {
-                    if val, exists := localRatio[modelName]; exists {
-                        localValue = val
-                    }
-                }
-            }
-
-            upstreamValues := make(map[string]interface{})
-            confidenceValues := make(map[string]bool)
-            hasUpstreamValue := false
-            hasDifference := false
-
-            for _, channel := range successfulChannels {
-                var upstreamValue interface{} = nil
-                
-                if upstreamRatio, ok := channel.data[ratioType].(map[string]any); ok {
-                    if val, exists := upstreamRatio[modelName]; exists {
-                        upstreamValue = val
-                        hasUpstreamValue = true
-                        
-                        if localValue != nil && localValue != val {
-                            hasDifference = true
-                        } else if localValue == val {
-                            upstreamValue = "same"
-                        }
-                    }
-                }
-                if upstreamValue == nil && localValue == nil {
-                    upstreamValue = "same"
-                }
-                
-                if localValue == nil && upstreamValue != nil && upstreamValue != "same" {
-                    hasDifference = true
-                }
-                
-                upstreamValues[channel.name] = upstreamValue
-                
-                confidenceValues[channel.name] = confidenceMap[channel.name][modelName]
-            }
-
-            shouldInclude := false
-            
-            if localValue != nil {
-                if hasDifference {
-                    shouldInclude = true
-                }
-            } else {
-                if hasUpstreamValue {
-                    shouldInclude = true
-                }
-            }
-
-            if shouldInclude {
-                if differences[modelName] == nil {
-                    differences[modelName] = make(map[string]dto.DifferenceItem)
-                }
-                differences[modelName][ratioType] = dto.DifferenceItem{
-                    Current:   localValue,
-                    Upstreams: upstreamValues,
-                    Confidence: confidenceValues,
-                }
-            }
-        }
-    }
-
-    channelHasDiff := make(map[string]bool)
-    for _, ratioMap := range differences {
-        for _, item := range ratioMap {
-            for chName, val := range item.Upstreams {
-                if val != nil && val != "same" {
-                    channelHasDiff[chName] = true
-                }
-            }
-        }
-    }
-
-    for modelName, ratioMap := range differences {
-        for ratioType, item := range ratioMap {
-            for chName := range item.Upstreams {
-                if !channelHasDiff[chName] {
-                    delete(item.Upstreams, chName)
-                    delete(item.Confidence, chName)
-                }
-            }
-
-            allSame := true
-            for _, v := range item.Upstreams {
-                if v != "same" {
-                    allSame = false
-                    break
-                }
-            }
-            if len(item.Upstreams) == 0 || allSame {
-                delete(ratioMap, ratioType)
-            } else {
-                differences[modelName][ratioType] = item
-            }
-        }
-
-        if len(ratioMap) == 0 {
-            delete(differences, modelName)
-        }
-    }
-
-    return differences
-}
-
-func GetSyncableChannels(c *gin.Context) {
-    channels, err := model.GetAllChannels(0, 0, true, false)
-    if err != nil {
-        c.JSON(http.StatusOK, gin.H{
-            "success": false,
-            "message": err.Error(),
-        })
-        return
-    }
-
-    var syncableChannels []dto.SyncableChannel
-    for _, channel := range channels {
-        if channel.GetBaseURL() != "" {
-            syncableChannels = append(syncableChannels, dto.SyncableChannel{
-                ID:      channel.Id,
-                Name:    channel.Name,
-                BaseURL: channel.GetBaseURL(),
-                Status:  channel.Status,
-            })
-        }
-    }
-
-    c.JSON(http.StatusOK, gin.H{
-        "success": true,
-        "message": "",
-        "data":    syncableChannels,
-    })
-} 
--- a/controller/redemption.go
+++ b/controller/redemption.go
@@ -1,25 +1,19 @@
 package controller

 import (
+	"github.com/gin-gonic/gin"
 	"net/http"
 	"one-api/common"
 	"one-api/model"
 	"strconv"
-	"errors"
-
-	"github.com/gin-gonic/gin"
 )

 func GetAllRedemptions(c *gin.Context) {
 	p, _ := strconv.Atoi(c.Query("p"))
-	pageSize, _ := strconv.Atoi(c.Query("page_size"))
 	if p < 0 {
 		p = 0
 	}
-	if pageSize < 1 {
-		pageSize = common.ItemsPerPage
-	}
-	redemptions, total, err := model.GetAllRedemptions((p-1)*pageSize, pageSize)
+	redemptions, err := model.GetAllRedemptions(p*common.ItemsPerPage, common.ItemsPerPage)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
@@ -30,27 +24,14 @@ func GetAllRedemptions(c *gin.Context) {
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
 		"message": "",
-		"data": gin.H{
-			"items":     redemptions,
-			"total":     total,
-			"page":      p,
-			"page_size": pageSize,
-		},
+		"data":    redemptions,
 	})
 	return
 }

 func SearchRedemptions(c *gin.Context) {
 	keyword := c.Query("keyword")
-	p, _ := strconv.Atoi(c.Query("p"))
-	pageSize, _ := strconv.Atoi(c.Query("page_size"))
-	if p < 0 {
-		p = 0
-	}
-	if pageSize < 1 {
-		pageSize = common.ItemsPerPage
-	}
-	redemptions, total, err := model.SearchRedemptions(keyword, (p-1)*pageSize, pageSize)
+	redemptions, err := model.SearchRedemptions(keyword)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
@@ -61,12 +42,7 @@ func SearchRedemptions(c *gin.Context) {
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
 		"message": "",
-		"data": gin.H{
-			"items":     redemptions,
-			"total":     total,
-			"page":      p,
-			"page_size": pageSize,
-		},
+		"data":    redemptions,
 	})
 	return
 }
@@ -127,10 +103,6 @@ func AddRedemption(c *gin.Context) {
 		})
 		return
 	}
-	if err := validateExpiredTime(redemption.ExpiredTime); err != nil {
-		c.JSON(http.StatusOK, gin.H{"success": false, "message": err.Error()})
-		return
-	}
 	var keys []string
 	for i := 0; i < redemption.Count; i++ {
 		key := common.GetUUID()
@@ -140,7 +112,6 @@ func AddRedemption(c *gin.Context) {
 			Key:         key,
 			CreatedTime: common.GetTimestamp(),
 			Quota:       redemption.Quota,
-			ExpiredTime: redemption.ExpiredTime,
 		}
 		err = cleanRedemption.Insert()
 		if err != nil {
@@ -197,18 +168,12 @@ func UpdateRedemption(c *gin.Context) {
 		})
 		return
 	}
-	if statusOnly == "" {
-		if err := validateExpiredTime(redemption.ExpiredTime); err != nil {
-			c.JSON(http.StatusOK, gin.H{"success": false, "message": err.Error()})
-			return
-		}
+	if statusOnly != "" {
+		cleanRedemption.Status = redemption.Status
+	} else {
 		// If you add more fields, please also update redemption.Update()
 		cleanRedemption.Name = redemption.Name
 		cleanRedemption.Quota = redemption.Quota
-		cleanRedemption.ExpiredTime = redemption.ExpiredTime
-	}
-	if statusOnly != "" {
-		cleanRedemption.Status = redemption.Status
 	}
 	err = cleanRedemption.Update()
 	if err != nil {
@@ -225,27 +190,3 @@ func UpdateRedemption(c *gin.Context) {
 	})
 	return
 }
-
-func DeleteInvalidRedemption(c *gin.Context) {
-	rows, err := model.DeleteInvalidRedemptions()
-	if err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": err.Error(),
-		})
-		return
-	}
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"message": "",
-		"data": rows,
-	})
-	return
-}
-
-func validateExpiredTime(expired int64) error {
-	if expired != 0 && expired < common.GetTimestamp() {
-		return errors.New("过期时间不能早于当前时间")
-	}
-	return nil
-}
--- a/controller/relay.go
+++ b/controller/relay.go
@@ -2,108 +2,81 @@ package controller

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

 func relayHandler(c *gin.Context, relayMode int) *dto.OpenAIErrorWithStatusCode {
 	var err *dto.OpenAIErrorWithStatusCode
 	switch relayMode {
-	case relayconstant.RelayModeImagesGenerations, relayconstant.RelayModeImagesEdits:
-		err = relay.ImageHelper(c)
+	case relayconstant.RelayModeImagesGenerations:
+		err = relay.RelayImageHelper(c, relayMode)
 	case relayconstant.RelayModeAudioSpeech:
 		fallthrough
 	case relayconstant.RelayModeAudioTranslation:
 		fallthrough
 	case relayconstant.RelayModeAudioTranscription:
-		err = relay.AudioHelper(c)
-	case relayconstant.RelayModeRerank:
-		err = relay.RerankHelper(c, relayMode)
-	case relayconstant.RelayModeEmbeddings:
-		err = relay.EmbeddingHelper(c)
-	case relayconstant.RelayModeResponses:
-		err = relay.ResponsesHelper(c)
-	case relayconstant.RelayModeGemini:
-		err = relay.GeminiHelper(c)
+		err = relay.AudioHelper(c, relayMode)
 	default:
 		err = relay.TextHelper(c)
 	}
-
-	if constant2.ErrorLogEnabled && err != nil {
-		// 保存错误日志到mysql中
-		userId := c.GetInt("id")
-		tokenName := c.GetString("token_name")
-		modelName := c.GetString("original_model")
-		tokenId := c.GetInt("token_id")
-		userGroup := c.GetString("group")
-		channelId := c.GetInt("channel_id")
-		other := make(map[string]interface{})
-		other["error_type"] = err.Error.Type
-		other["error_code"] = err.Error.Code
-		other["status_code"] = err.StatusCode
-		other["channel_id"] = channelId
-		other["channel_name"] = c.GetString("channel_name")
-		other["channel_type"] = c.GetInt("channel_type")
-
-		model.RecordErrorLog(c, userId, channelId, modelName, tokenName, err.Error.Message, tokenId, 0, false, userGroup, other)
-	}
-
 	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")
-	var openaiErr *dto.OpenAIErrorWithStatusCode
-
-	for i := 0; i <= common.RetryTimes; i++ {
-		channel, err := getChannel(c, group, originalModel, i)
+	openaiErr := relayHandler(c, relayMode)
+	c.Set("use_channel", []string{fmt.Sprintf("%d", 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, err.Error())
-			openaiErr = service.OpenAIErrorWrapperLocal(err, "get_channel_failed", http.StatusInternalServerError)
+			common.LogError(c.Request.Context(), fmt.Sprintf("CacheGetRandomSatisfiedChannel failed: %s", err.Error()))
 			break
 		}
+		channelId = channel.Id
+		useChannel := c.GetStringSlice("use_channel")
+		useChannel = append(useChannel, fmt.Sprintf("%d", channelId))
+		c.Set("use_channel", useChannel)
+		common.LogInfo(c.Request.Context(), fmt.Sprintf("using channel #%d to retry (remain times %d)", channel.Id, i))
+		middleware.SetupContextForSelectedChannel(c, channel, originalModel)

-		openaiErr = relayRequest(c, relayMode, channel)
-
-		if openaiErr == nil {
-			return // 成功处理请求，直接返回
-		}
-
-		go processChannelError(c, channel.Id, channel.Type, channel.Name, channel.GetAutoBan(), openaiErr)
-
-		if !shouldRetry(c, openaiErr, common.RetryTimes-i) {
-			break
+		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)
 		}
 	}
 	useChannel := c.GetStringSlice("use_channel")
 	if len(useChannel) > 1 {
 		retryLogStr := fmt.Sprintf("重试：%s", strings.Trim(strings.Join(strings.Fields(fmt.Sprint(useChannel)), "->"), "[]"))
-		common.LogInfo(c, retryLogStr)
+		common.LogInfo(c.Request.Context(), retryLogStr)
 	}

 	if openaiErr != nil {
 		if openaiErr.StatusCode == http.StatusTooManyRequests {
-			common.LogError(c, fmt.Sprintf("origin 429 error: %s", openaiErr.Error.Message))
 			openaiErr.Error.Message = "当前分组上游负载已饱和，请稍后再试"
 		}
 		openaiErr.Error.Message = common.MessageWithRequestId(openaiErr.Error.Message, requestId)
@@ -113,167 +86,10 @@ func Relay(c *gin.Context) {
 	}
 }

-var upgrader = websocket.Upgrader{
-	Subprotocols: []string{"realtime"}, // WS 握手支持的协议，如果有使用 Sec-WebSocket-Protocol，则必须在此声明对应的 Protocol TODO add other protocol
-	CheckOrigin: func(r *http.Request) bool {
-		return true // 允许跨域
-	},
-}
-
-func WssRelay(c *gin.Context) {
-	// 将 HTTP 连接升级为 WebSocket 连接
-
-	ws, err := upgrader.Upgrade(c.Writer, c.Request, nil)
-	defer ws.Close()
-
-	if err != nil {
-		openaiErr := service.OpenAIErrorWrapper(err, "get_channel_failed", http.StatusInternalServerError)
-		helper.WssError(c, ws, openaiErr.Error)
-		return
-	}
-
-	relayMode := constant.Path2RelayMode(c.Request.URL.Path)
-	requestId := c.GetString(common.RequestIdKey)
-	group := c.GetString("group")
-	//wss://api.openai.com/v1/realtime?model=gpt-4o-realtime-preview-2024-10-01
-	originalModel := c.GetString("original_model")
-	var openaiErr *dto.OpenAIErrorWithStatusCode
-
-	for i := 0; i <= common.RetryTimes; i++ {
-		channel, err := getChannel(c, group, originalModel, i)
-		if err != nil {
-			common.LogError(c, err.Error())
-			openaiErr = service.OpenAIErrorWrapperLocal(err, "get_channel_failed", http.StatusInternalServerError)
-			break
-		}
-
-		openaiErr = wssRequest(c, ws, relayMode, channel)
-
-		if openaiErr == nil {
-			return // 成功处理请求，直接返回
-		}
-
-		go processChannelError(c, channel.Id, channel.Type, channel.Name, channel.GetAutoBan(), openaiErr)
-
-		if !shouldRetry(c, openaiErr, common.RetryTimes-i) {
-			break
-		}
-	}
-	useChannel := c.GetStringSlice("use_channel")
-	if len(useChannel) > 1 {
-		retryLogStr := fmt.Sprintf("重试：%s", strings.Trim(strings.Join(strings.Fields(fmt.Sprint(useChannel)), "->"), "[]"))
-		common.LogInfo(c, retryLogStr)
-	}
-
-	if openaiErr != nil {
-		if openaiErr.StatusCode == http.StatusTooManyRequests {
-			openaiErr.Error.Message = "当前分组上游负载已饱和，请稍后再试"
-		}
-		openaiErr.Error.Message = common.MessageWithRequestId(openaiErr.Error.Message, requestId)
-		helper.WssError(c, ws, openaiErr.Error)
-	}
-}
-
-func RelayClaude(c *gin.Context) {
-	//relayMode := constant.Path2RelayMode(c.Request.URL.Path)
-	requestId := c.GetString(common.RequestIdKey)
-	group := c.GetString("group")
-	originalModel := c.GetString("original_model")
-	var claudeErr *dto.ClaudeErrorWithStatusCode
-
-	for i := 0; i <= common.RetryTimes; i++ {
-		channel, err := getChannel(c, group, originalModel, i)
-		if err != nil {
-			common.LogError(c, err.Error())
-			claudeErr = service.ClaudeErrorWrapperLocal(err, "get_channel_failed", http.StatusInternalServerError)
-			break
-		}
-
-		claudeErr = claudeRequest(c, channel)
-
-		if claudeErr == nil {
-			return // 成功处理请求，直接返回
-		}
-
-		openaiErr := service.ClaudeErrorToOpenAIError(claudeErr)
-
-		go processChannelError(c, channel.Id, channel.Type, channel.Name, channel.GetAutoBan(), openaiErr)
-
-		if !shouldRetry(c, openaiErr, common.RetryTimes-i) {
-			break
-		}
-	}
-	useChannel := c.GetStringSlice("use_channel")
-	if len(useChannel) > 1 {
-		retryLogStr := fmt.Sprintf("重试：%s", strings.Trim(strings.Join(strings.Fields(fmt.Sprint(useChannel)), "->"), "[]"))
-		common.LogInfo(c, retryLogStr)
-	}
-
-	if claudeErr != nil {
-		claudeErr.Error.Message = common.MessageWithRequestId(claudeErr.Error.Message, requestId)
-		c.JSON(claudeErr.StatusCode, gin.H{
-			"type":  "error",
-			"error": claudeErr.Error,
-		})
-	}
-}
-
-func relayRequest(c *gin.Context, relayMode int, channel *model.Channel) *dto.OpenAIErrorWithStatusCode {
-	addUsedChannel(c, channel.Id)
-	requestBody, _ := common.GetRequestBody(c)
-	c.Request.Body = io.NopCloser(bytes.NewBuffer(requestBody))
-	return relayHandler(c, relayMode)
-}
-
-func wssRequest(c *gin.Context, ws *websocket.Conn, relayMode int, channel *model.Channel) *dto.OpenAIErrorWithStatusCode {
-	addUsedChannel(c, channel.Id)
-	requestBody, _ := common.GetRequestBody(c)
-	c.Request.Body = io.NopCloser(bytes.NewBuffer(requestBody))
-	return relay.WssHelper(c, ws)
-}
-
-func claudeRequest(c *gin.Context, channel *model.Channel) *dto.ClaudeErrorWithStatusCode {
-	addUsedChannel(c, channel.Id)
-	requestBody, _ := common.GetRequestBody(c)
-	c.Request.Body = io.NopCloser(bytes.NewBuffer(requestBody))
-	return relay.ClaudeHelper(c)
-}
-
-func addUsedChannel(c *gin.Context, channelId int) {
-	useChannel := c.GetStringSlice("use_channel")
-	useChannel = append(useChannel, fmt.Sprintf("%d", channelId))
-	c.Set("use_channel", useChannel)
-}
-
-func getChannel(c *gin.Context, group, originalModel string, retryCount int) (*model.Channel, error) {
-	if retryCount == 0 {
-		autoBan := c.GetBool("auto_ban")
-		autoBanInt := 1
-		if !autoBan {
-			autoBanInt = 0
-		}
-		return &model.Channel{
-			Id:      c.GetInt("channel_id"),
-			Type:    c.GetInt("channel_type"),
-			Name:    c.GetString("channel_name"),
-			AutoBan: &autoBanInt,
-		}, nil
-	}
-	channel, _, err := model.CacheGetRandomSatisfiedChannel(c, group, originalModel, retryCount)
-	if err != nil {
-		return nil, errors.New(fmt.Sprintf("获取重试渠道失败: %s", err.Error()))
-	}
-	middleware.SetupContextForSelectedChannel(c, channel, originalModel)
-	return channel, nil
-}
-
-func shouldRetry(c *gin.Context, openaiErr *dto.OpenAIErrorWithStatusCode, retryTimes int) bool {
+func shouldRetry(c *gin.Context, channelId int, openaiErr *dto.OpenAIErrorWithStatusCode, retryTimes int) bool {
 	if openaiErr == nil {
 		return false
 	}
-	if openaiErr.LocalError {
-		return false
-	}
 	if retryTimes <= 0 {
 		return false
 	}
@@ -294,27 +110,26 @@ func shouldRetry(c *gin.Context, openaiErr *dto.OpenAIErrorWithStatusCode, retry
 		return true
 	}
 	if openaiErr.StatusCode == http.StatusBadRequest {
-		channelType := c.GetInt("channel_type")
-		if channelType == common.ChannelTypeAnthropic {
-			return true
-		}
 		return false
 	}
 	if openaiErr.StatusCode == 408 {
 		// azure处理超时不重试
 		return false
 	}
+	if openaiErr.LocalError {
+		return false
+	}
 	if openaiErr.StatusCode/100 == 2 {
 		return false
 	}
 	return true
 }

-func processChannelError(c *gin.Context, channelId int, channelType int, channelName string, autoBan bool, err *dto.OpenAIErrorWithStatusCode) {
-	// 不要使用context获取渠道信息，异步处理时可能会出现渠道信息不一致的情况
-	// do not use context to get channel info, there may be inconsistent channel info when processing asynchronously
-	common.LogError(c, fmt.Sprintf("relay error (channel #%d, status code: %d): %s", channelId, err.StatusCode, err.Error.Message))
-	if service.ShouldDisableChannel(channelType, err) && autoBan {
+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, status code: %d): %s", channelId, err.StatusCode, err.Error.Message))
+	if service.ShouldDisableChannel(&err.Error, err.StatusCode) && autoBan {
+		channelName := c.GetString("channel_name")
 		service.DisableChannel(channelId, channelName, err.Error.Message)
 	}
 }
@@ -388,16 +203,16 @@ func RelayTask(c *gin.Context) {
 		retryTimes = 0
 	}
 	for i := 0; shouldRetryTaskRelay(c, channelId, taskErr, retryTimes) && i < retryTimes; i++ {
-		channel, _, err := model.CacheGetRandomSatisfiedChannel(c, group, originalModel, i)
+		channel, err := model.CacheGetRandomSatisfiedChannel(group, originalModel, i)
 		if err != nil {
-			common.LogError(c, fmt.Sprintf("CacheGetRandomSatisfiedChannel failed: %s", err.Error()))
+			common.LogError(c.Request.Context(), fmt.Sprintf("CacheGetRandomSatisfiedChannel failed: %s", err.Error()))
 			break
 		}
 		channelId = channel.Id
 		useChannel := c.GetStringSlice("use_channel")
 		useChannel = append(useChannel, fmt.Sprintf("%d", channelId))
 		c.Set("use_channel", useChannel)
-		common.LogInfo(c, fmt.Sprintf("using channel #%d to retry (remain times %d)", channel.Id, i))
+		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)
@@ -407,7 +222,7 @@ func RelayTask(c *gin.Context) {
 	useChannel := c.GetStringSlice("use_channel")
 	if len(useChannel) > 1 {
 		retryLogStr := fmt.Sprintf("重试：%s", strings.Trim(strings.Join(strings.Fields(fmt.Sprint(useChannel)), "->"), "[]"))
-		common.LogInfo(c, retryLogStr)
+		common.LogInfo(c.Request.Context(), retryLogStr)
 	}
 	if taskErr != nil {
 		if taskErr.StatusCode == http.StatusTooManyRequests {
@@ -420,7 +235,7 @@ func RelayTask(c *gin.Context) {
 func taskRelayHandler(c *gin.Context, relayMode int) *dto.TaskError {
 	var err *dto.TaskError
 	switch relayMode {
-	case relayconstant.RelayModeSunoFetch, relayconstant.RelayModeSunoFetchByID, relayconstant.RelayModeKlingFetchByID:
+	case relayconstant.RelayModeSunoFetch, relayconstant.RelayModeSunoFetchByID:
 		err = relay.RelayTaskFetch(c, relayMode)
 	default:
 		err = relay.RelayTaskSubmit(c, relayMode)
--- a/controller/setup.go
+++ b/controller/setup.go
@@ -1,181 +0,0 @@
-package controller
-
-import (
-	"github.com/gin-gonic/gin"
-	"one-api/common"
-	"one-api/constant"
-	"one-api/model"
-	"one-api/setting/operation_setting"
-	"time"
-)
-
-type Setup struct {
-	Status       bool   `json:"status"`
-	RootInit     bool   `json:"root_init"`
-	DatabaseType string `json:"database_type"`
-}
-
-type SetupRequest struct {
-	Username           string `json:"username"`
-	Password           string `json:"password"`
-	ConfirmPassword    string `json:"confirmPassword"`
-	SelfUseModeEnabled bool   `json:"SelfUseModeEnabled"`
-	DemoSiteEnabled    bool   `json:"DemoSiteEnabled"`
-}
-
-func GetSetup(c *gin.Context) {
-	setup := Setup{
-		Status: constant.Setup,
-	}
-	if constant.Setup {
-		c.JSON(200, gin.H{
-			"success": true,
-			"data":    setup,
-		})
-		return
-	}
-	setup.RootInit = model.RootUserExists()
-	if common.UsingMySQL {
-		setup.DatabaseType = "mysql"
-	}
-	if common.UsingPostgreSQL {
-		setup.DatabaseType = "postgres"
-	}
-	if common.UsingSQLite {
-		setup.DatabaseType = "sqlite"
-	}
-	c.JSON(200, gin.H{
-		"success": true,
-		"data":    setup,
-	})
-}
-
-func PostSetup(c *gin.Context) {
-	// Check if setup is already completed
-	if constant.Setup {
-		c.JSON(400, gin.H{
-			"success": false,
-			"message": "系统已经初始化完成",
-		})
-		return
-	}
-
-	// Check if root user already exists
-	rootExists := model.RootUserExists()
-
-	var req SetupRequest
-	err := c.ShouldBindJSON(&req)
-	if err != nil {
-		c.JSON(400, gin.H{
-			"success": false,
-			"message": "请求参数有误",
-		})
-		return
-	}
-
-	// If root doesn't exist, validate and create admin account
-	if !rootExists {
-		// Validate username length: max 12 characters to align with model.User validation
-		if len(req.Username) > 12 {
-			c.JSON(400, gin.H{
-				"success": false,
-				"message": "用户名长度不能超过12个字符",
-			})
-			return
-		}
-		// Validate password
-		if req.Password != req.ConfirmPassword {
-			c.JSON(400, gin.H{
-				"success": false,
-				"message": "两次输入的密码不一致",
-			})
-			return
-		}
-
-		if len(req.Password) < 8 {
-			c.JSON(400, gin.H{
-				"success": false,
-				"message": "密码长度至少为8个字符",
-			})
-			return
-		}
-
-		// Create root user
-		hashedPassword, err := common.Password2Hash(req.Password)
-		if err != nil {
-			c.JSON(500, gin.H{
-				"success": false,
-				"message": "系统错误: " + err.Error(),
-			})
-			return
-		}
-		rootUser := model.User{
-			Username:    req.Username,
-			Password:    hashedPassword,
-			Role:        common.RoleRootUser,
-			Status:      common.UserStatusEnabled,
-			DisplayName: "Root User",
-			AccessToken: nil,
-			Quota:       100000000,
-		}
-		err = model.DB.Create(&rootUser).Error
-		if err != nil {
-			c.JSON(500, gin.H{
-				"success": false,
-				"message": "创建管理员账号失败: " + err.Error(),
-			})
-			return
-		}
-	}
-
-	// Set operation modes
-	operation_setting.SelfUseModeEnabled = req.SelfUseModeEnabled
-	operation_setting.DemoSiteEnabled = req.DemoSiteEnabled
-
-	// Save operation modes to database for persistence
-	err = model.UpdateOption("SelfUseModeEnabled", boolToString(req.SelfUseModeEnabled))
-	if err != nil {
-		c.JSON(500, gin.H{
-			"success": false,
-			"message": "保存自用模式设置失败: " + err.Error(),
-		})
-		return
-	}
-
-	err = model.UpdateOption("DemoSiteEnabled", boolToString(req.DemoSiteEnabled))
-	if err != nil {
-		c.JSON(500, gin.H{
-			"success": false,
-			"message": "保存演示站点模式设置失败: " + err.Error(),
-		})
-		return
-	}
-
-	// Update setup status
-	constant.Setup = true
-
-	setup := model.Setup{
-		Version:       common.Version,
-		InitializedAt: time.Now().Unix(),
-	}
-	err = model.DB.Create(&setup).Error
-	if err != nil {
-		c.JSON(500, gin.H{
-			"success": false,
-			"message": "系统初始化失败: " + err.Error(),
-		})
-		return
-	}
-
-	c.JSON(200, gin.H{
-		"success": true,
-		"message": "系统初始化成功",
-	})
-}
-
-func boolToString(b bool) string {
-	if b {
-		return "true"
-	}
-	return "false"
-}
--- a/controller/task.go
+++ b/controller/task.go
@@ -1,6 +1,7 @@
 package controller

 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"errors"
@@ -13,7 +14,7 @@ import (
 	"one-api/constant"
 	"one-api/dto"
 	"one-api/model"
-	"one-api/relay"
+	"one-api/service"
 	"sort"
 	"strconv"
 	"time"
@@ -74,8 +75,6 @@ func UpdateTaskByPlatform(platform constant.TaskPlatform, taskChannelM map[int][
 		//_ = UpdateMidjourneyTaskAll(context.Background(), tasks)
 	case constant.TaskPlatformSuno:
 		_ = UpdateSunoTaskAll(context.Background(), taskChannelM, taskM)
-	case constant.TaskPlatformKling:
-		_ = UpdateVideoTaskAll(context.Background(), taskChannelM, taskM)
 	default:
 		common.SysLog("未知平台")
 	}
@@ -109,13 +108,26 @@ func updateSunoTaskAll(ctx context.Context, channelId int, taskIds []string, tas
 		}
 		return err
 	}
-	adaptor := relay.GetTaskAdaptor(constant.TaskPlatformSuno)
-	if adaptor == nil {
-		return errors.New("adaptor not found")
-	}
-	resp, err := adaptor.FetchTask(*channel.BaseURL, channel.Key, map[string]any{
+	requestUrl := fmt.Sprintf("%s/fetch", *channel.BaseURL)
+
+	body, _ := json.Marshal(map[string]any{
 		"ids": taskIds,
 	})
+	req, err := http.NewRequest("POST", requestUrl, bytes.NewBuffer(body))
+	if err != nil {
+		common.SysError(fmt.Sprintf("Get Task error: %v", err))
+		return err
+	}
+	defer req.Body.Close()
+	// 设置超时时间
+	timeout := time.Second * 15
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+	// 使用带有超时的 context 创建新的请求
+	req = req.WithContext(ctx)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+channel.Key)
+	resp, err := service.GetHttpClient().Do(req)
 	if err != nil {
 		common.SysError(fmt.Sprintf("Get Task Do req error: %v", err))
 		return err
@@ -133,7 +145,7 @@ func updateSunoTaskAll(ctx context.Context, channelId int, taskIds []string, tas
 	var responseItems dto.TaskResponse[[]dto.SunoDataResponse]
 	err = json.Unmarshal(responseBody, &responseItems)
 	if err != nil {
-		common.LogError(ctx, fmt.Sprintf("Get Task parse body error2: %v, body: %s", err, string(responseBody)))
+		common.LogError(ctx, fmt.Sprintf("Get Task parse body error2: %v, req: %s, body: %s", err, string(body), string(responseBody)))
 		return err
 	}
 	if !responseItems.IsSuccess() {
@@ -155,13 +167,13 @@ func updateSunoTaskAll(ctx context.Context, channelId int, taskIds []string, tas
 		if responseItem.FailReason != "" || task.Status == model.TaskStatusFailure {
 			common.LogInfo(ctx, task.TaskID+" 构建失败，"+task.FailReason)
 			task.Progress = "100%"
-			//err = model.CacheUpdateUserQuota(task.UserId) ?
+			err = model.CacheUpdateUserQuota(task.UserId)
 			if err != nil {
 				common.LogError(ctx, "error update user quota cache: "+err.Error())
 			} else {
 				quota := task.Quota
 				if quota != 0 {
-					err = model.IncreaseUserQuota(task.UserId, quota, false)
+					err = model.IncreaseUserQuota(task.UserId, quota)
 					if err != nil {
 						common.LogError(ctx, "fail to increase user quota: "+err.Error())
 					}
@@ -226,14 +238,9 @@ func checkTaskNeedUpdate(oldTask *model.Task, newTask dto.SunoDataResponse) bool

 func GetAllTask(c *gin.Context) {
 	p, _ := strconv.Atoi(c.Query("p"))
-	if p < 1 {
-		p = 1
+	if p < 0 {
+		p = 0
 	}
-	pageSize, _ := strconv.Atoi(c.Query("page_size"))
-	if pageSize <= 0 {
-		pageSize = common.ItemsPerPage
-	}
-
 	startTimestamp, _ := strconv.ParseInt(c.Query("start_timestamp"), 10, 64)
 	endTimestamp, _ := strconv.ParseInt(c.Query("end_timestamp"), 10, 64)
 	// 解析其他查询参数
@@ -244,32 +251,24 @@ func GetAllTask(c *gin.Context) {
 		Action:         c.Query("action"),
 		StartTimestamp: startTimestamp,
 		EndTimestamp:   endTimestamp,
-		ChannelID:      c.Query("channel_id"),
 	}

-	items := model.TaskGetAllTasks((p-1)*pageSize, pageSize, queryParams)
-	total := model.TaskCountAllTasks(queryParams)
+	logs := model.TaskGetAllTasks(p*common.ItemsPerPage, common.ItemsPerPage, queryParams)
+	if logs == nil {
+		logs = make([]*model.Task, 0)
+	}

 	c.JSON(200, gin.H{
 		"success": true,
 		"message": "",
-		"data": gin.H{
-			"items":     items,
-			"total":     total,
-			"page":      p,
-			"page_size": pageSize,
-		},
+		"data":    logs,
 	})
 }

 func GetUserTask(c *gin.Context) {
 	p, _ := strconv.Atoi(c.Query("p"))
-	if p < 1 {
-		p = 1
-	}
-	pageSize, _ := strconv.Atoi(c.Query("page_size"))
-	if pageSize <= 0 {
-		pageSize = common.ItemsPerPage
+	if p < 0 {
+		p = 0
 	}

 	userId := c.GetInt("id")
@@ -286,17 +285,14 @@ func GetUserTask(c *gin.Context) {
 		EndTimestamp:   endTimestamp,
 	}

-	items := model.TaskGetAllUserTask(userId, (p-1)*pageSize, pageSize, queryParams)
-	total := model.TaskCountAllUserTask(userId, queryParams)
+	logs := model.TaskGetAllUserTask(userId, p*common.ItemsPerPage, common.ItemsPerPage, queryParams)
+	if logs == nil {
+		logs = make([]*model.Task, 0)
+	}

 	c.JSON(200, gin.H{
 		"success": true,
 		"message": "",
-		"data": gin.H{
-			"items":     items,
-			"total":     total,
-			"page":      p,
-			"page_size": pageSize,
-		},
+		"data":    logs,
 	})
 }
--- a/controller/task_video.go
+++ b/controller/task_video.go
@@ -1,140 +0,0 @@
-package controller
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"one-api/common"
-	"one-api/constant"
-	"one-api/model"
-	"one-api/relay"
-	"one-api/relay/channel"
-)
-
-func UpdateVideoTaskAll(ctx context.Context, taskChannelM map[int][]string, taskM map[string]*model.Task) error {
-	for channelId, taskIds := range taskChannelM {
-		if err := updateVideoTaskAll(ctx, channelId, taskIds, taskM); err != nil {
-			common.LogError(ctx, fmt.Sprintf("Channel #%d failed to update video async tasks: %s", channelId, err.Error()))
-		}
-	}
-	return nil
-}
-
-func updateVideoTaskAll(ctx context.Context, channelId int, taskIds []string, taskM map[string]*model.Task) error {
-	common.LogInfo(ctx, fmt.Sprintf("Channel #%d pending video tasks: %d", channelId, len(taskIds)))
-	if len(taskIds) == 0 {
-		return nil
-	}
-	cacheGetChannel, err := model.CacheGetChannel(channelId)
-	if err != nil {
-		errUpdate := model.TaskBulkUpdate(taskIds, map[string]any{
-			"fail_reason": fmt.Sprintf("Failed to get channel info, channel ID: %d", channelId),
-			"status":      "FAILURE",
-			"progress":    "100%",
-		})
-		if errUpdate != nil {
-			common.SysError(fmt.Sprintf("UpdateVideoTask error: %v", errUpdate))
-		}
-		return fmt.Errorf("CacheGetChannel failed: %w", err)
-	}
-	adaptor := relay.GetTaskAdaptor(constant.TaskPlatformKling)
-	if adaptor == nil {
-		return fmt.Errorf("video adaptor not found")
-	}
-	for _, taskId := range taskIds {
-		if err := updateVideoSingleTask(ctx, adaptor, cacheGetChannel, taskId, taskM); err != nil {
-			common.LogError(ctx, fmt.Sprintf("Failed to update video task %s: %s", taskId, err.Error()))
-		}
-	}
-	return nil
-}
-
-func updateVideoSingleTask(ctx context.Context, adaptor channel.TaskAdaptor, channel *model.Channel, taskId string, taskM map[string]*model.Task) error {
-	baseURL := common.ChannelBaseURLs[channel.Type]
-	if channel.GetBaseURL() != "" {
-		baseURL = channel.GetBaseURL()
-	}
-	resp, err := adaptor.FetchTask(baseURL, channel.Key, map[string]any{
-		"task_id": taskId,
-	})
-	if err != nil {
-		return fmt.Errorf("FetchTask failed for task %s: %w", taskId, err)
-	}
-	if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("Get Video Task status code: %d", resp.StatusCode)
-	}
-	defer resp.Body.Close()
-	responseBody, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return fmt.Errorf("ReadAll failed for task %s: %w", taskId, err)
-	}
-
-	var responseItem map[string]interface{}
-	err = json.Unmarshal(responseBody, &responseItem)
-	if err != nil {
-		common.LogError(ctx, fmt.Sprintf("Failed to parse video task response body: %v, body: %s", err, string(responseBody)))
-		return fmt.Errorf("Unmarshal failed for task %s: %w", taskId, err)
-	}
-
-	code, _ := responseItem["code"].(float64)
-	if code != 0 {
-		return fmt.Errorf("video task fetch failed for task %s", taskId)
-	}
-
-	data, ok := responseItem["data"].(map[string]interface{})
-	if !ok {
-		common.LogError(ctx, fmt.Sprintf("Video task data format error: %s", string(responseBody)))
-		return fmt.Errorf("video task data format error for task %s", taskId)
-	}
-
-	task := taskM[taskId]
-	if task == nil {
-		common.LogError(ctx, fmt.Sprintf("Task %s not found in taskM", taskId))
-		return fmt.Errorf("task %s not found", taskId)
-	}
-
-	if status, ok := data["task_status"].(string); ok {
-		switch status {
-		case "submitted", "queued":
-			task.Status = model.TaskStatusSubmitted
-		case "processing":
-			task.Status = model.TaskStatusInProgress
-		case "succeed":
-			task.Status = model.TaskStatusSuccess
-			task.Progress = "100%"
-			if url, err := adaptor.ParseResultUrl(responseItem); err == nil {
-				task.FailReason = url
-			} else {
-				common.LogWarn(ctx, fmt.Sprintf("Failed to get url from body for task %s: %s", task.TaskID, err.Error()))
-			}
-		case "failed":
-			task.Status = model.TaskStatusFailure
-			task.Progress = "100%"
-			if reason, ok := data["fail_reason"].(string); ok {
-				task.FailReason = reason
-			}
-		}
-	}
-
-	// If task failed, refund quota
-	if task.Status == model.TaskStatusFailure {
-		common.LogInfo(ctx, fmt.Sprintf("Task %s failed: %s", task.TaskID, task.FailReason))
-		quota := task.Quota
-		if quota != 0 {
-			if err := model.IncreaseUserQuota(task.UserId, quota, false); err != nil {
-				common.LogError(ctx, "Failed to increase user quota: "+err.Error())
-			}
-			logContent := fmt.Sprintf("Video async task failed %s, refund %s", task.TaskID, common.LogQuota(quota))
-			model.RecordLog(task.UserId, model.LogTypeSystem, logContent)
-		}
-	}
-
-	task.Data = responseBody
-	if err := task.Update(); err != nil {
-		common.SysError("UpdateVideoTask task error: " + err.Error())
-	}
-
-	return nil
-}
--- a/controller/telegram.go
+++ b/controller/telegram.go
@@ -5,7 +5,6 @@ import (
 	"crypto/sha256"
 	"encoding/hex"
 	"io"
-	"net/http"
 	"one-api/common"
 	"one-api/model"
 	"sort"
@@ -49,13 +48,6 @@ func TelegramBind(c *gin.Context) {
 		})
 		return
 	}
-	if user.Id == 0 {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": "用户已注销",
-		})
-		return
-	}
 	user.TelegramId = telegramId
 	if err := user.Update(false); err != nil {
 		c.JSON(200, gin.H{
--- a/controller/token.go
+++ b/controller/token.go
@@ -12,15 +12,15 @@ func GetAllTokens(c *gin.Context) {
 	userId := c.GetInt("id")
 	p, _ := strconv.Atoi(c.Query("p"))
 	size, _ := strconv.Atoi(c.Query("size"))
-	if p < 1 {
-		p = 1
+	if p < 0 {
+		p = 0
 	}
 	if size <= 0 {
 		size = common.ItemsPerPage
 	} else if size > 100 {
 		size = 100
 	}
-	tokens, err := model.GetAllUserTokens(userId, (p-1)*size, size)
+	tokens, err := model.GetAllUserTokens(userId, p*size, size)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
@@ -28,18 +28,10 @@ func GetAllTokens(c *gin.Context) {
 		})
 		return
 	}
-	// Get total count for pagination
-	total, _ := model.CountUserTokens(userId)
-
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
 		"message": "",
-		"data": gin.H{
-			"items":     tokens,
-			"total":     total,
-			"page":      p,
-			"page_size": size,
-		},
+		"data":    tokens,
 	})
 	return
 }
@@ -131,19 +123,10 @@ func AddToken(c *gin.Context) {
 		})
 		return
 	}
-	key, err := common.GenerateKey()
-	if err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": "生成令牌失败",
-		})
-		common.SysError("failed to generate token key: " + err.Error())
-		return
-	}
 	cleanToken := model.Token{
 		UserId:             c.GetInt("id"),
 		Name:               token.Name,
-		Key:                key,
+		Key:                common.GenerateKey(),
 		CreatedTime:        common.GetTimestamp(),
 		AccessedTime:       common.GetTimestamp(),
 		ExpiredTime:        token.ExpiredTime,
@@ -151,8 +134,6 @@ func AddToken(c *gin.Context) {
 		UnlimitedQuota:     token.UnlimitedQuota,
 		ModelLimitsEnabled: token.ModelLimitsEnabled,
 		ModelLimits:        token.ModelLimits,
-		AllowIps:           token.AllowIps,
-		Group:              token.Group,
 	}
 	err = cleanToken.Insert()
 	if err != nil {
@@ -240,8 +221,6 @@ func UpdateToken(c *gin.Context) {
 		cleanToken.UnlimitedQuota = token.UnlimitedQuota
 		cleanToken.ModelLimitsEnabled = token.ModelLimitsEnabled
 		cleanToken.ModelLimits = token.ModelLimits
-		cleanToken.AllowIps = token.AllowIps
-		cleanToken.Group = token.Group
 	}
 	err = cleanToken.Update()
 	if err != nil {
@@ -258,32 +237,3 @@ func UpdateToken(c *gin.Context) {
 	})
 	return
 }
-
-type TokenBatch struct {
-	Ids []int `json:"ids"`
-}
-
-func DeleteTokenBatch(c *gin.Context) {
-	tokenBatch := TokenBatch{}
-	if err := c.ShouldBindJSON(&tokenBatch); err != nil || len(tokenBatch.Ids) == 0 {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": "参数错误",
-		})
-		return
-	}
-	userId := c.GetInt("id")
-	count, err := model.BatchDeleteTokens(tokenBatch.Ids, userId)
-	if err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": err.Error(),
-		})
-		return
-	}
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"message": "",
-		"data":    count,
-	})
-}
--- a/controller/topup.go
+++ b/controller/topup.go
@@ -2,76 +2,65 @@ package controller

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

 type EpayRequest struct {
-	Amount        int64  `json:"amount"`
+	Amount        int    `json:"amount"`
 	PaymentMethod string `json:"payment_method"`
 	TopUpCode     string `json:"top_up_code"`
 }

 type AmountRequest struct {
-	Amount    int64  `json:"amount"`
+	Amount    int    `json:"amount"`
 	TopUpCode string `json:"top_up_code"`
 }

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

-func getPayMoney(amount int64, group string) float64 {
-	dAmount := decimal.NewFromInt(amount)
-
+func getPayMoney(amount float64, user model.User) float64 {
 	if !common.DisplayInCurrencyEnabled {
-		dQuotaPerUnit := decimal.NewFromFloat(common.QuotaPerUnit)
-		dAmount = dAmount.Div(dQuotaPerUnit)
+		amount = amount / common.QuotaPerUnit
 	}
-
-	topupGroupRatio := common.GetTopupGroupRatio(group)
+	// 别问为什么用float64，问就是这么点钱没必要
+	topupGroupRatio := common.GetTopupGroupRatio(user.Group)
 	if topupGroupRatio == 0 {
 		topupGroupRatio = 1
 	}
-
-	dTopupGroupRatio := decimal.NewFromFloat(topupGroupRatio)
-	dPrice := decimal.NewFromFloat(setting.Price)
-
-	payMoney := dAmount.Mul(dPrice).Mul(dTopupGroupRatio)
-
-	return payMoney.InexactFloat64()
+	payMoney := amount * constant.Price * topupGroupRatio
+	return payMoney
 }

-func getMinTopup() int64 {
-	minTopup := setting.MinTopUp
+func getMinTopup() int {
+	minTopup := constant.MinTopUp
 	if !common.DisplayInCurrencyEnabled {
-		dMinTopup := decimal.NewFromInt(int64(minTopup))
-		dQuotaPerUnit := decimal.NewFromFloat(common.QuotaPerUnit)
-		minTopup = int(dMinTopup.Mul(dQuotaPerUnit).IntPart())
+		minTopup = minTopup * int(common.QuotaPerUnit)
 	}
-	return int64(minTopup)
+	return minTopup
 }

 func RequestEpay(c *gin.Context) {
@@ -87,36 +76,34 @@ func RequestEpay(c *gin.Context) {
 	}

 	id := c.GetInt("id")
-	group, err := model.GetUserGroup(id, true)
-	if err != nil {
-		c.JSON(200, gin.H{"message": "error", "data": "获取用户分组失败"})
-		return
-	}
-	payMoney := getPayMoney(req.Amount, group)
+	user, _ := model.GetUserById(id, false)
+	payMoney := getPayMoney(float64(req.Amount), *user)
 	if payMoney < 0.01 {
 		c.JSON(200, gin.H{"message": "error", "data": "充值金额过低"})
 		return
 	}

-	if !setting.ContainsPayMethod(req.PaymentMethod) {
-		c.JSON(200, gin.H{"message": "error", "data": "支付方式不存在"})
-		return
+	var payType epay.PurchaseType
+	if req.PaymentMethod == "zfb" {
+		payType = epay.Alipay
+	}
+	if req.PaymentMethod == "wx" {
+		req.PaymentMethod = "wxpay"
+		payType = epay.WechatPay
 	}
-
 	callBackAddress := service.GetCallbackAddress()
-	returnUrl, _ := url.Parse(setting.ServerAddress + "/console/log")
+	returnUrl, _ := url.Parse(constant.ServerAddress + "/log")
 	notifyUrl, _ := url.Parse(callBackAddress + "/api/user/epay/notify")
 	tradeNo := fmt.Sprintf("%s%d", common.GetRandomString(6), time.Now().Unix())
-	tradeNo = fmt.Sprintf("USR%dNO%s", id, tradeNo)
 	client := GetEpayClient()
 	if client == nil {
 		c.JSON(200, gin.H{"message": "error", "data": "当前管理员未配置支付信息"})
 		return
 	}
 	uri, params, err := client.Purchase(&epay.PurchaseArgs{
-		Type:           req.PaymentMethod,
-		ServiceTradeNo: tradeNo,
-		Name:           fmt.Sprintf("TUC%d", req.Amount),
+		Type:           payType,
+		ServiceTradeNo: "A" + tradeNo,
+		Name:           "B" + tradeNo,
 		Money:          strconv.FormatFloat(payMoney, 'f', 2, 64),
 		Device:         epay.PC,
 		NotifyUrl:      notifyUrl,
@@ -128,15 +115,13 @@ func RequestEpay(c *gin.Context) {
 	}
 	amount := req.Amount
 	if !common.DisplayInCurrencyEnabled {
-		dAmount := decimal.NewFromInt(int64(amount))
-		dQuotaPerUnit := decimal.NewFromFloat(common.QuotaPerUnit)
-		amount = dAmount.Div(dQuotaPerUnit).IntPart()
+		amount = amount / int(common.QuotaPerUnit)
 	}
 	topUp := &model.TopUp{
 		UserId:     id,
 		Amount:     amount,
 		Money:      payMoney,
-		TradeNo:    tradeNo,
+		TradeNo:    "A" + tradeNo,
 		CreateTime: time.Now().Unix(),
 		Status:     "pending",
 	}
@@ -222,16 +207,13 @@ func EpayNotify(c *gin.Context) {
 			}
 			//user, _ := model.GetUserById(topUp.UserId, false)
 			//user.Quota += topUp.Amount * 500000
-			dAmount := decimal.NewFromInt(int64(topUp.Amount))
-			dQuotaPerUnit := decimal.NewFromFloat(common.QuotaPerUnit)
-			quotaToAdd := int(dAmount.Mul(dQuotaPerUnit).IntPart())
-			err = model.IncreaseUserQuota(topUp.UserId, quotaToAdd, true)
+			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(quotaToAdd), 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)
@@ -251,12 +233,8 @@ func RequestAmount(c *gin.Context) {
 		return
 	}
 	id := c.GetInt("id")
-	group, err := model.GetUserGroup(id, true)
-	if err != nil {
-		c.JSON(200, gin.H{"message": "error", "data": "获取用户分组失败"})
-		return
-	}
-	payMoney := getPayMoney(req.Amount, group)
+	user, _ := model.GetUserById(id, false)
+	payMoney := getPayMoney(float64(req.Amount), *user)
 	if payMoney <= 0.01 {
 		c.JSON(200, gin.H{"message": "error", "data": "充值金额过低"})
 		return
--- a/controller/uptime_kuma.go
+++ b/controller/uptime_kuma.go
@@ -1,154 +0,0 @@
-package controller
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"net/http"
-	"one-api/setting/console_setting"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/gin-gonic/gin"
-	"golang.org/x/sync/errgroup"
-)
-
-const (
-	requestTimeout   = 30 * time.Second
-	httpTimeout      = 10 * time.Second
-	uptimeKeySuffix  = "_24"
-	apiStatusPath    = "/api/status-page/"
-	apiHeartbeatPath = "/api/status-page/heartbeat/"
-)
-
-type Monitor struct {
-	Name   string  `json:"name"`
-	Uptime float64 `json:"uptime"`
-	Status int     `json:"status"`
-	Group  string  `json:"group,omitempty"`
-}
-
-type UptimeGroupResult struct {
-	CategoryName string    `json:"categoryName"`
-	Monitors  []Monitor `json:"monitors"`
-}
-
-func getAndDecode(ctx context.Context, client *http.Client, url string, dest interface{}) error {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
-	if err != nil {
-		return err
-	}
-
-	resp, err := client.Do(req)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return errors.New("non-200 status")
-	}
-
-	return json.NewDecoder(resp.Body).Decode(dest)
-}
-
-func fetchGroupData(ctx context.Context, client *http.Client, groupConfig map[string]interface{}) UptimeGroupResult {
-	url, _ := groupConfig["url"].(string)
-	slug, _ := groupConfig["slug"].(string)
-	categoryName, _ := groupConfig["categoryName"].(string)
-	
-	result := UptimeGroupResult{
-		CategoryName: categoryName,
-		Monitors:  []Monitor{},
-	}
-	
-	if url == "" || slug == "" {
-		return result
-	}
-
-	baseURL := strings.TrimSuffix(url, "/")
-	
-	var statusData struct {
-		PublicGroupList []struct {
-			ID   int    `json:"id"`
-			Name string `json:"name"`
-			MonitorList []struct {
-				ID   int    `json:"id"`
-				Name string `json:"name"`
-			} `json:"monitorList"`
-		} `json:"publicGroupList"`
-	}
-	
-	var heartbeatData struct {
-		HeartbeatList map[string][]struct {
-			Status int `json:"status"`
-		} `json:"heartbeatList"`
-		UptimeList map[string]float64 `json:"uptimeList"`
-	}
-
-	g, gCtx := errgroup.WithContext(ctx)
-	g.Go(func() error { 
-		return getAndDecode(gCtx, client, baseURL+apiStatusPath+slug, &statusData) 
-	})
-	g.Go(func() error { 
-		return getAndDecode(gCtx, client, baseURL+apiHeartbeatPath+slug, &heartbeatData) 
-	})
-
-	if g.Wait() != nil {
-		return result
-	}
-
-	for _, pg := range statusData.PublicGroupList {
-		if len(pg.MonitorList) == 0 {
-			continue
-		}
-
-		for _, m := range pg.MonitorList {
-			monitor := Monitor{
-				Name:  m.Name,
-				Group: pg.Name,
-			}
-
-			monitorID := strconv.Itoa(m.ID)
-
-			if uptime, exists := heartbeatData.UptimeList[monitorID+uptimeKeySuffix]; exists {
-				monitor.Uptime = uptime
-			}
-
-			if heartbeats, exists := heartbeatData.HeartbeatList[monitorID]; exists && len(heartbeats) > 0 {
-				monitor.Status = heartbeats[0].Status
-			}
-
-			result.Monitors = append(result.Monitors, monitor)
-		}
-	}
-
-	return result
-}
-
-func GetUptimeKumaStatus(c *gin.Context) {
-	groups := console_setting.GetUptimeKumaGroups()
-	if len(groups) == 0 {
-		c.JSON(http.StatusOK, gin.H{"success": true, "message": "", "data": []UptimeGroupResult{}})
-		return
-	}
-
-	ctx, cancel := context.WithTimeout(c.Request.Context(), requestTimeout)
-	defer cancel()
-
-	client := &http.Client{Timeout: httpTimeout}
-	results := make([]UptimeGroupResult, len(groups))
-	
-	g, gCtx := errgroup.WithContext(ctx)
-	for i, group := range groups {
-		i, group := i, group
-		g.Go(func() error {
-			results[i] = fetchGroupData(gCtx, client, group)
-			return nil
-		})
-	}
-	
-	g.Wait()
-	c.JSON(http.StatusOK, gin.H{"success": true, "message": "", "data": results})
-} 
--- a/controller/user.go
+++ b/controller/user.go
@@ -4,16 +4,11 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
-	"net/url"
 	"one-api/common"
 	"one-api/model"
-	"one-api/setting"
 	"strconv"
-	"strings"
 	"sync"

-	"one-api/constant"
-
 	"github.com/gin-contrib/sessions"
 	"github.com/gin-gonic/gin"
 )
@@ -71,7 +66,6 @@ func setupLogin(user *model.User, c *gin.Context) {
 	session.Set("username", user.Username)
 	session.Set("role", user.Role)
 	session.Set("status", user.Status)
-	session.Set("group", user.Group)
 	err := session.Save()
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
@@ -163,9 +157,8 @@ func Register(c *gin.Context) {
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
-			"message": "数据库错误，请稍后重试",
+			"message": err.Error(),
 		})
-		common.SysError(fmt.Sprintf("CheckUserExistOrDeleted error: %v", err))
 		return
 	}
 	if exist {
@@ -193,51 +186,6 @@ func Register(c *gin.Context) {
 		})
 		return
 	}
-
-	// 获取插入后的用户ID
-	var insertedUser model.User
-	if err := model.DB.Where("username = ?", cleanUser.Username).First(&insertedUser).Error; err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": "用户注册失败或用户ID获取失败",
-		})
-		return
-	}
-	// 生成默认令牌
-	if constant.GenerateDefaultToken {
-		key, err := common.GenerateKey()
-		if err != nil {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": "生成默认令牌失败",
-			})
-			common.SysError("failed to generate token key: " + err.Error())
-			return
-		}
-		// 生成默认令牌
-		token := model.Token{
-			UserId:             insertedUser.Id, // 使用插入后的用户ID
-			Name:               cleanUser.Username + "的初始令牌",
-			Key:                key,
-			CreatedTime:        common.GetTimestamp(),
-			AccessedTime:       common.GetTimestamp(),
-			ExpiredTime:        -1,     // 永不过期
-			RemainQuota:        500000, // 示例额度
-			UnlimitedQuota:     true,
-			ModelLimitsEnabled: false,
-		}
-		if setting.DefaultUseAutoGroup {
-			token.Group = "auto"
-		}
-		if err := token.Insert(); err != nil {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": "创建默认令牌失败",
-			})
-			return
-		}
-	}
-
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
 		"message": "",
@@ -247,14 +195,10 @@ func Register(c *gin.Context) {

 func GetAllUsers(c *gin.Context) {
 	p, _ := strconv.Atoi(c.Query("p"))
-	pageSize, _ := strconv.Atoi(c.Query("page_size"))
-	if p < 1 {
-		p = 1
+	if p < 0 {
+		p = 0
 	}
-	if pageSize < 0 {
-		pageSize = common.ItemsPerPage
-	}
-	users, total, err := model.GetAllUsers((p-1)*pageSize, pageSize)
+	users, err := model.GetAllUsers(p*common.ItemsPerPage, common.ItemsPerPage)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
@@ -265,12 +209,7 @@ func GetAllUsers(c *gin.Context) {
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
 		"message": "",
-		"data": gin.H{
-			"items":     users,
-			"total":     total,
-			"page":      p,
-			"page_size": pageSize,
-		},
+		"data":    users,
 	})
 	return
 }
@@ -278,16 +217,7 @@ func GetAllUsers(c *gin.Context) {
 func SearchUsers(c *gin.Context) {
 	keyword := c.Query("keyword")
 	group := c.Query("group")
-	p, _ := strconv.Atoi(c.Query("p"))
-	pageSize, _ := strconv.Atoi(c.Query("page_size"))
-	if p < 1 {
-		p = 1
-	}
-	if pageSize < 0 {
-		pageSize = common.ItemsPerPage
-	}
-	startIdx := (p - 1) * pageSize
-	users, total, err := model.SearchUsers(keyword, group, startIdx, pageSize)
+	users, err := model.SearchUsers(keyword, group)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
@@ -298,12 +228,7 @@ func SearchUsers(c *gin.Context) {
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
 		"message": "",
-		"data": gin.H{
-			"items":     users,
-			"total":     total,
-			"page":      p,
-			"page_size": pageSize,
-		},
+		"data":    users,
 	})
 	return
 }
@@ -351,18 +276,7 @@ func GenerateAccessToken(c *gin.Context) {
 		})
 		return
 	}
-	// get rand int 28-32
-	randI := common.GetRandomInt(4)
-	key, err := common.GenerateRandomKey(29 + randI)
-	if err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": "生成失败",
-		})
-		common.SysError("failed to generate key: " + err.Error())
-		return
-	}
-	user.SetAccessToken(key)
+	user.AccessToken = common.GetUUID()

 	if model.DB.Where("access_token = ?", user.AccessToken).First(user).RowsAffected != 0 {
 		c.JSON(http.StatusOK, gin.H{
@@ -462,9 +376,6 @@ func GetSelf(c *gin.Context) {
 		})
 		return
 	}
-	// Hide admin remarks: set to empty to trigger omitempty tag, ensuring the remark field is not included in JSON returned to regular users
-	user.Remark = ""
-
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
 		"message": "",
@@ -478,7 +389,7 @@ func GetUserModels(c *gin.Context) {
 	if err != nil {
 		id = c.GetInt("id")
 	}
-	user, err := model.GetUserCache(id)
+	user, err := model.GetUserById(id, true)
 	if err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
@@ -486,15 +397,7 @@ func GetUserModels(c *gin.Context) {
 		})
 		return
 	}
-	groups := setting.GetUserUsableGroups(user.Group)
-	var models []string
-	for group := range groups {
-		for _, g := range model.GetGroupModels(group) {
-			if !common.StringsContains(models, g) {
-				models = append(models, g)
-			}
-		}
-	}
+	models := model.GetGroupModels(user.Group)
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
 		"message": "",
@@ -598,14 +501,7 @@ func UpdateSelf(c *gin.Context) {
 		user.Password = "" // rollback to what it should be
 		cleanUser.Password = ""
 	}
-	updatePassword, err := checkUpdatePassword(user.OriginalPassword, user.Password, cleanUser.Id)
-	if err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": err.Error(),
-		})
-		return
-	}
+	updatePassword := user.Password != ""
 	if err := cleanUser.Update(updatePassword); err != nil {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
@@ -621,23 +517,6 @@ func UpdateSelf(c *gin.Context) {
 	return
 }

-func checkUpdatePassword(originalPassword string, newPassword string, userId int) (updatePassword bool, err error) {
-	var currentUser *model.User
-	currentUser, err = model.GetUserById(userId, true)
-	if err != nil {
-		return
-	}
-	if !common.ValidatePasswordAndHash(originalPassword, currentUser.Password) {
-		err = fmt.Errorf("原密码错误")
-		return
-	}
-	if newPassword == "" {
-		return
-	}
-	updatePassword = true
-	return
-}
-
 func DeleteUser(c *gin.Context) {
 	id, err := strconv.Atoi(c.Param("id"))
 	if err != nil {
@@ -703,7 +582,6 @@ func DeleteSelf(c *gin.Context) {
 func CreateUser(c *gin.Context) {
 	var user model.User
 	err := json.NewDecoder(c.Request.Body).Decode(&user)
-	user.Username = strings.TrimSpace(user.Username)
 	if err != nil || user.Username == "" || user.Password == "" {
 		c.JSON(http.StatusOK, gin.H{
 			"success": false,
@@ -751,8 +629,8 @@ func CreateUser(c *gin.Context) {
 }

 type ManageRequest struct {
-	Id     int    `json:"id"`
-	Action string `json:"action"`
+	Username string `json:"username"`
+	Action   string `json:"action"`
 }

 // ManageUser Only admin user can do this
@@ -768,7 +646,7 @@ func ManageUser(c *gin.Context) {
 		return
 	}
 	user := model.User{
-		Id: req.Id,
+		Username: req.Username,
 	}
 	// Fill attributes
 	model.DB.Unscoped().Where(&user).First(&user)
@@ -877,10 +755,9 @@ func EmailBind(c *gin.Context) {
 		})
 		return
 	}
-	session := sessions.Default(c)
-	id := session.Get("id")
+	id := c.GetInt("id")
 	user := model.User{
-		Id: id.(int),
+		Id: id,
 	}
 	err := user.FillUserById()
 	if err != nil {
@@ -900,6 +777,9 @@ func EmailBind(c *gin.Context) {
 		})
 		return
 	}
+	if user.Role == common.RoleRootUser {
+		common.RootUserEmail = email
+	}
 	c.JSON(http.StatusOK, gin.H{
 		"success": true,
 		"message": "",
@@ -911,11 +791,11 @@ type topUpRequest struct {
 	Key string `json:"key"`
 }

-var topUpLock = sync.Mutex{}
+var lock = sync.Mutex{}

 func TopUp(c *gin.Context) {
-	topUpLock.Lock()
-	defer topUpLock.Unlock()
+	lock.Lock()
+	defer lock.Unlock()
 	req := topUpRequest{}
 	err := c.ShouldBindJSON(&req)
 	if err != nil {
@@ -941,119 +821,3 @@ func TopUp(c *gin.Context) {
 	})
 	return
 }
-
-type UpdateUserSettingRequest struct {
-	QuotaWarningType           string  `json:"notify_type"`
-	QuotaWarningThreshold      float64 `json:"quota_warning_threshold"`
-	WebhookUrl                 string  `json:"webhook_url,omitempty"`
-	WebhookSecret              string  `json:"webhook_secret,omitempty"`
-	NotificationEmail          string  `json:"notification_email,omitempty"`
-	AcceptUnsetModelRatioModel bool    `json:"accept_unset_model_ratio_model"`
-	RecordIpLog                bool    `json:"record_ip_log"`
-}
-
-func UpdateUserSetting(c *gin.Context) {
-	var req UpdateUserSettingRequest
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": "无效的参数",
-		})
-		return
-	}
-
-	// 验证预警类型
-	if req.QuotaWarningType != constant.NotifyTypeEmail && req.QuotaWarningType != constant.NotifyTypeWebhook {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": "无效的预警类型",
-		})
-		return
-	}
-
-	// 验证预警阈值
-	if req.QuotaWarningThreshold <= 0 {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": "预警阈值必须大于0",
-		})
-		return
-	}
-
-	// 如果是webhook类型,验证webhook地址
-	if req.QuotaWarningType == constant.NotifyTypeWebhook {
-		if req.WebhookUrl == "" {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": "Webhook地址不能为空",
-			})
-			return
-		}
-		// 验证URL格式
-		if _, err := url.ParseRequestURI(req.WebhookUrl); err != nil {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": "无效的Webhook地址",
-			})
-			return
-		}
-	}
-
-	// 如果是邮件类型，验证邮箱地址
-	if req.QuotaWarningType == constant.NotifyTypeEmail && req.NotificationEmail != "" {
-		// 验证邮箱格式
-		if !strings.Contains(req.NotificationEmail, "@") {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": "无效的邮箱地址",
-			})
-			return
-		}
-	}
-
-	userId := c.GetInt("id")
-	user, err := model.GetUserById(userId, true)
-	if err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": err.Error(),
-		})
-		return
-	}
-
-	// 构建设置
-	settings := map[string]interface{}{
-		constant.UserSettingNotifyType:            req.QuotaWarningType,
-		constant.UserSettingQuotaWarningThreshold: req.QuotaWarningThreshold,
-		"accept_unset_model_ratio_model":          req.AcceptUnsetModelRatioModel,
-		constant.UserSettingRecordIpLog:           req.RecordIpLog,
-	}
-
-	// 如果是webhook类型,添加webhook相关设置
-	if req.QuotaWarningType == constant.NotifyTypeWebhook {
-		settings[constant.UserSettingWebhookUrl] = req.WebhookUrl
-		if req.WebhookSecret != "" {
-			settings[constant.UserSettingWebhookSecret] = req.WebhookSecret
-		}
-	}
-
-	// 如果提供了通知邮箱，添加到设置中
-	if req.QuotaWarningType == constant.NotifyTypeEmail && req.NotificationEmail != "" {
-		settings[constant.UserSettingNotificationEmail] = req.NotificationEmail
-	}
-
-	// 更新用户设置
-	user.SetSetting(settings)
-	if err := user.Update(false); err != nil {
-		c.JSON(http.StatusOK, gin.H{
-			"success": false,
-			"message": "更新设置失败: " + err.Error(),
-		})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"message": "设置已更新",
-	})
-}
--- a/controller/wechat.go
+++ b/controller/wechat.go
@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/gin-contrib/sessions"
 	"github.com/gin-gonic/gin"
 	"net/http"
 	"one-api/common"
@@ -79,13 +78,6 @@ func WeChatAuth(c *gin.Context) {
 			})
 			return
 		}
-		if user.Id == 0 {
-			c.JSON(http.StatusOK, gin.H{
-				"success": false,
-				"message": "用户已注销",
-			})
-			return
-		}
 	} else {
 		if common.RegisterEnabled {
 			user.Username = "wechat_" + strconv.Itoa(model.GetMaxUserId()+1)
@@ -143,10 +135,9 @@ func WeChatBind(c *gin.Context) {
 		})
 		return
 	}
-	session := sessions.Default(c)
-	id := session.Get("id")
+	id := c.GetInt("id")
 	user := model.User{
-		Id: id.(int),
+		Id: id,
 	}
 	err = user.FillUserById()
 	if err != nil {
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -3,6 +3,7 @@ version: '3.4'
 services:
  new-api:
    image: calciumion/new-api:latest
+    # build: .
    container_name: new-api
    restart: always
    command: --log-dir /app/logs
@@ -12,21 +13,18 @@ services:
      - ./data:/data
      - ./logs:/app/logs
    environment:
-      - SQL_DSN=root:123456@tcp(mysql:3306)/new-api  # Point to the mysql service
+      - SQL_DSN=root:123456@tcp(host.docker.internal:3306)/new-api  # 修改此行，或注释掉以使用 SQLite 作为数据库
      - REDIS_CONN_STRING=redis://redis
+      - SESSION_SECRET=random_string  # 修改为随机字符串
      - TZ=Asia/Shanghai
-      - ERROR_LOG_ENABLED=true # 是否启用错误日志记录
-    #      - TIKTOKEN_CACHE_DIR=./tiktoken_cache  # 如果需要使用tiktoken_cache，请取消注释
-    #      - SESSION_SECRET=random_string  # 多机部署时设置，必须修改这个随机字符串！！！！！！！
-    #      - NODE_TYPE=slave  # Uncomment for slave node in multi-node deployment
-    #      - SYNC_FREQUENCY=60  # Uncomment if regular database syncing is needed
-    #      - FRONTEND_BASE_URL=https://openai.justsong.cn  # Uncomment for multi-node deployment with front-end URL
+#      - NODE_TYPE=slave  # 多机部署时从节点取消注释该行
+#      - SYNC_FREQUENCY=60  # 需要定期从数据库加载数据时取消注释该行
+#      - FRONTEND_BASE_URL=https://openai.justsong.cn  # 多机部署时从节点取消注释该行

    depends_on:
      - redis
-      - mysql
    healthcheck:
-      test: ["CMD-SHELL", "wget -q -O - http://localhost:3000/api/status | grep -o '\"success\":\\s*true' | awk -F: '{print $$2}'"]
+      test: [ "CMD-SHELL", "wget -q -O - http://localhost:3000/api/status | grep -o '\"success\":\\s*true' | awk -F: '{print $2}'" ]
      interval: 30s
      timeout: 10s
      retries: 3
@@ -35,18 +33,3 @@ services:
    image: redis:latest
    container_name: redis
    restart: always
-
-  mysql:
-    image: mysql:8.2
-    container_name: mysql
-    restart: always
-    environment:
-      MYSQL_ROOT_PASSWORD: 123456  # Ensure this matches the password in SQL_DSN
-      MYSQL_DATABASE: new-api
-    volumes:
-      - mysql_data:/var/lib/mysql
-    # ports:
-    #   - "3306:3306"  # If you want to access MySQL from outside Docker, uncomment
-
-volumes:
-  mysql_data:
--- a/docs/api/api_auth.md
+++ b/docs/api/api_auth.md
@@ -1,53 +0,0 @@
-# API 鉴权文档
-
-## 认证方式
-
-### Access Token
-
-对于需要鉴权的 API 接口，必须同时提供以下两个请求头来进行 Access Token 认证：
-
-1. **请求头中的 `Authorization` 字段**
-
-    将 Access Token 放置于 HTTP 请求头部的 `Authorization` 字段中，格式如下：
-
-    ```
-    Authorization: <your_access_token>
-    ```
-
-    其中 `<your_access_token>` 需要替换为实际的 Access Token 值。
-
-2. **请求头中的 `New-Api-User` 字段**
-
-    将用户 ID 放置于 HTTP 请求头部的 `New-Api-User` 字段中，格式如下：
-
-    ```
-    New-Api-User: <your_user_id>
-    ```
-
-    其中 `<your_user_id>` 需要替换为实际的用户 ID。
-
-**注意：**
-
-*   **必须同时提供 `Authorization` 和 `New-Api-User` 两个请求头才能通过鉴权。**
-*   如果只提供其中一个请求头，或者两个请求头都未提供，则会返回 `401 Unauthorized` 错误。
-*   如果 `Authorization` 中的 Access Token 无效，则会返回 `401 Unauthorized` 错误，并提示“无权进行此操作，access token 无效”。
-*   如果 `New-Api-User` 中的用户 ID 与 Access Token 不匹配，则会返回 `401 Unauthorized` 错误，并提示“无权进行此操作，与登录用户不匹配，请重新登录”。
-*   如果没有提供 `New-Api-User` 请求头，则会返回 `401 Unauthorized` 错误，并提示“无权进行此操作，未提供 New-Api-User”。
-*   如果 `New-Api-User` 请求头格式错误，则会返回 `401 Unauthorized` 错误，并提示“无权进行此操作，New-Api-User 格式错误”。
-*   如果用户已被禁用，则会返回 `403 Forbidden` 错误，并提示“用户已被封禁”。
-*   如果用户权限不足，则会返回 `403 Forbidden` 错误，并提示“无权进行此操作，权限不足”。
-*   如果用户信息无效，则会返回 `403 Forbidden` 错误，并提示“无权进行此操作，用户信息无效”。
-
-## Curl 示例
-
-假设您的 Access Token 为 `access_token`，用户 ID 为 `123`，要访问的 API 接口为 `/api/user/self`，则可以使用以下 curl 命令：
-
-```bash
-curl -X GET \
-  -H "Authorization: access_token" \
-  -H "New-Api-User: 123" \
-  https://your-domain.com/api/user/self
-```
-
-请将 `access_token`、`123` 和 `https://your-domain.com` 替换为实际的值。
-
--- a/docs/api/user.md
+++ b/docs/api/user.md
--- a/docs/channel/other_setting.md
+++ b/docs/channel/other_setting.md
@@ -1,33 +0,0 @@
-# 渠道而外设置说明
-
-该配置用于设置一些额外的渠道参数，可以通过 JSON 对象进行配置。主要包含以下两个设置项：
-
-1. force_format
-    - 用于标识是否对数据进行强制格式化为 OpenAI 格式
-    - 类型为布尔值，设置为 true 时启用强制格式化
-
-2. proxy
-    - 用于配置网络代理
-    - 类型为字符串，填写代理地址（例如 socks5 协议的代理地址）
-
-3. thinking_to_content
-   - 用于标识是否将思考内容`reasoning_content`转换为`<think>`标签拼接到内容中返回
-   - 类型为布尔值，设置为 true 时启用思考内容转换
-
--------------------------------------------------------------
-
-## JSON 格式示例
-
-以下是一个示例配置，启用强制格式化并设置了代理地址：
-
-```json
-{
-    "force_format": true,
-   "thinking_to_content": true,
-    "proxy": "socks5://xxxxxxx"
-}
-```
-
--------------------------------------------------------------
-
-通过调整上述 JSON 配置中的值，可以灵活控制渠道的额外行为，比如是否进行格式化以及使用特定的网络代理。
--- a/docs/installation/BT.md
+++ b/docs/installation/BT.md
@@ -1,3 +0,0 @@
-密钥为环境变量SESSION_SECRET
-
-![8285bba413e770fe9620f1bf9b40d44e](https://github.com/user-attachments/assets/7a6fc03e-c457-45e4-b8f9-184508fc26b0)
--- a/docs/models/Rerank.md
+++ b/docs/models/Rerank.md
@@ -1,62 +0,0 @@
-# Rerank API文档
-
-**简介**:Rerank API文档
-
-## 接入Dify
-模型供应商选择Jina，按要求填写模型信息即可接入Dify。
-
-## 请求方式
-
-Post: /v1/rerank
-
-Request:
-
-```json
-{
-  "model": "jina-reranker-v2-base-multilingual",
-  "query": "What is the capital of the United States?",
-  "top_n": 3,
-  "documents": [
-    "Carson City is the capital city of the American state of Nevada.",
-    "The Commonwealth of the Northern Mariana Islands is a group of islands in the Pacific Ocean. Its capital is Saipan.",
-    "Washington, D.C. (also known as simply Washington or D.C., and officially as the District of Columbia) is the capital of the United States. It is a federal district.",
-    "Capitalization or capitalisation in English grammar is the use of a capital letter at the start of a word. English usage varies from capitalization in other languages.",
-    "Capital punishment (the death penalty) has existed in the United States since beforethe United States was a country. As of 2017, capital punishment is legal in 30 of the 50 states."
-  ]
-}
-```
-
-Response:
-
-```json
-{
-  "results": [
-    {
-      "document": {
-        "text": "Washington, D.C. (also known as simply Washington or D.C., and officially as the District of Columbia) is the capital of the United States. It is a federal district."
-      },
-      "index": 2,
-      "relevance_score": 0.9999702
-    },
-    {
-      "document": {
-        "text": "Carson City is the capital city of the American state of Nevada."
-      },
-      "index": 0,
-      "relevance_score": 0.67800725
-    },
-    {
-      "document": {
-        "text": "Capitalization or capitalisation in English grammar is the use of a capital letter at the start of a word. English usage varies from capitalization in other languages."
-      },
-      "index": 3,
-      "relevance_score": 0.02800752
-    }
-  ],
-  "usage": {
-    "prompt_tokens": 158,
-    "completion_tokens": 0,
-    "total_tokens": 158
-  }
-}
-```
--- a/docs/models/Suno.md
+++ b/docs/models/Suno.md
@@ -1,44 +0,0 @@
-# Suno API文档
-
-**简介**:Suno API文档
-
-## 接口列表
-支持的接口如下：
-+ [x] /suno/submit/music
-+ [x] /suno/submit/lyrics
-+ [x] /suno/fetch
-+ [x] /suno/fetch/:id
-
-## 模型列表
-
-### Suno API支持
-
- suno_music (自定义模式、灵感模式、续写)
- suno_lyrics (生成歌词)
-
-
-## 模型价格设置（在设置-运营设置-模型固定价格设置中设置）
-```json
-{
-  "suno_music": 0.3,
-  "suno_lyrics": 0.01
-}
-```
-
-## 渠道设置
-
-### 对接 Suno API
-
-1.
-部署 Suno API，并配置好suno账号等（强烈建议设置密钥），[项目地址](https://github.com/Suno-API/Suno-API)
-
-2. 在渠道管理中添加渠道，渠道类型选择**Suno API**
-   ，模型请参考上方模型列表
-3. **代理**填写 Suno API 部署的地址，例如：http://localhost:8080
-4. 密钥填写 Suno API 的密钥，如果没有设置密钥，可以随便填
-
-### 对接上游new api
-
-1. 在渠道管理中添加渠道，渠道类型选择**Suno API**，或任意类型，只需模型包含上方模型列表的模型
-2. **代理**填写上游new api的地址，例如：http://localhost:3000
-3. 密钥填写上游new api的密钥
--- a/dto/audio.go
+++ b/dto/audio.go
@@ -1,34 +1,13 @@
 package dto

-type AudioRequest struct {
-	Model          string  `json:"model"`
-	Input          string  `json:"input"`
-	Voice          string  `json:"voice"`
-	Speed          float64 `json:"speed,omitempty"`
-	ResponseFormat string  `json:"response_format,omitempty"`
+type TextToSpeechRequest struct {
+	Model          string  `json:"model" binding:"required"`
+	Input          string  `json:"input" binding:"required"`
+	Voice          string  `json:"voice" binding:"required"`
+	Speed          float64 `json:"speed"`
+	ResponseFormat string  `json:"response_format"`
 }

 type AudioResponse struct {
 	Text string `json:"text"`
 }
-
-type WhisperVerboseJSONResponse struct {
-	Task     string    `json:"task,omitempty"`
-	Language string    `json:"language,omitempty"`
-	Duration float64   `json:"duration,omitempty"`
-	Text     string    `json:"text,omitempty"`
-	Segments []Segment `json:"segments,omitempty"`
-}
-
-type Segment struct {
-	Id               int     `json:"id"`
-	Seek             int     `json:"seek"`
-	Start            float64 `json:"start"`
-	End              float64 `json:"end"`
-	Text             string  `json:"text"`
-	Tokens           []int   `json:"tokens"`
-	Temperature      float64 `json:"temperature"`
-	AvgLogprob       float64 `json:"avg_logprob"`
-	CompressionRatio float64 `json:"compression_ratio"`
-	NoSpeechProb     float64 `json:"no_speech_prob"`
-}
--- a/dto/claude.go
+++ b/dto/claude.go
@@ -1,257 +0,0 @@
-package dto
-
-import (
-	"encoding/json"
-	"one-api/common"
-)
-
-type ClaudeMetadata struct {
-	UserId string `json:"user_id"`
-}
-
-type ClaudeMediaMessage struct {
-	Type         string               `json:"type,omitempty"`
-	Text         *string              `json:"text,omitempty"`
-	Model        string               `json:"model,omitempty"`
-	Source       *ClaudeMessageSource `json:"source,omitempty"`
-	Usage        *ClaudeUsage         `json:"usage,omitempty"`
-	StopReason   *string              `json:"stop_reason,omitempty"`
-	PartialJson  *string              `json:"partial_json,omitempty"`
-	Role         string               `json:"role,omitempty"`
-	Thinking     string               `json:"thinking,omitempty"`
-	Signature    string               `json:"signature,omitempty"`
-	Delta        string               `json:"delta,omitempty"`
-	CacheControl json.RawMessage      `json:"cache_control,omitempty"`
-	// tool_calls
-	Id        string `json:"id,omitempty"`
-	Name      string `json:"name,omitempty"`
-	Input     any    `json:"input,omitempty"`
-	Content   any    `json:"content,omitempty"`
-	ToolUseId string `json:"tool_use_id,omitempty"`
-}
-
-func (c *ClaudeMediaMessage) SetText(s string) {
-	c.Text = &s
-}
-
-func (c *ClaudeMediaMessage) GetText() string {
-	if c.Text == nil {
-		return ""
-	}
-	return *c.Text
-}
-
-func (c *ClaudeMediaMessage) IsStringContent() bool {
-	if c.Content == nil {
-		return false
-	}
-	_, ok := c.Content.(string)
-	if ok {
-		return true
-	}
-	return false
-}
-
-func (c *ClaudeMediaMessage) GetStringContent() string {
-	if c.Content == nil {
-		return ""
-	}
-	switch c.Content.(type) {
-	case string:
-		return c.Content.(string)
-	case []any:
-		var contentStr string
-		for _, contentItem := range c.Content.([]any) {
-			contentMap, ok := contentItem.(map[string]any)
-			if !ok {
-				continue
-			}
-			if contentMap["type"] == ContentTypeText {
-				if subStr, ok := contentMap["text"].(string); ok {
-					contentStr += subStr
-				}
-			}
-		}
-		return contentStr
-	}
-
-	return ""
-}
-
-func (c *ClaudeMediaMessage) GetJsonRowString() string {
-	jsonContent, _ := json.Marshal(c)
-	return string(jsonContent)
-}
-
-func (c *ClaudeMediaMessage) SetContent(content any) {
-	c.Content = content
-}
-
-func (c *ClaudeMediaMessage) ParseMediaContent() []ClaudeMediaMessage {
-	mediaContent, _ := common.Any2Type[[]ClaudeMediaMessage](c.Content)
-	return mediaContent
-}
-
-type ClaudeMessageSource struct {
-	Type      string `json:"type"`
-	MediaType string `json:"media_type,omitempty"`
-	Data      any    `json:"data,omitempty"`
-	Url       string `json:"url,omitempty"`
-}
-
-type ClaudeMessage struct {
-	Role    string `json:"role"`
-	Content any    `json:"content"`
-}
-
-func (c *ClaudeMessage) IsStringContent() bool {
-	if c.Content == nil {
-		return false
-	}
-	_, ok := c.Content.(string)
-	return ok
-}
-
-func (c *ClaudeMessage) GetStringContent() string {
-	if c.Content == nil {
-		return ""
-	}
-	switch c.Content.(type) {
-	case string:
-		return c.Content.(string)
-	case []any:
-		var contentStr string
-		for _, contentItem := range c.Content.([]any) {
-			contentMap, ok := contentItem.(map[string]any)
-			if !ok {
-				continue
-			}
-			if contentMap["type"] == ContentTypeText {
-				if subStr, ok := contentMap["text"].(string); ok {
-					contentStr += subStr
-				}
-			}
-		}
-		return contentStr
-	}
-
-	return ""
-}
-
-func (c *ClaudeMessage) SetStringContent(content string) {
-	c.Content = content
-}
-
-func (c *ClaudeMessage) ParseContent() ([]ClaudeMediaMessage, error) {
-	return common.Any2Type[[]ClaudeMediaMessage](c.Content)
-}
-
-type Tool struct {
-	Name        string                 `json:"name"`
-	Description string                 `json:"description,omitempty"`
-	InputSchema map[string]interface{} `json:"input_schema"`
-}
-
-type InputSchema struct {
-	Type       string `json:"type"`
-	Properties any    `json:"properties,omitempty"`
-	Required   any    `json:"required,omitempty"`
-}
-
-type ClaudeRequest struct {
-	Model             string          `json:"model"`
-	Prompt            string          `json:"prompt,omitempty"`
-	System            any             `json:"system,omitempty"`
-	Messages          []ClaudeMessage `json:"messages,omitempty"`
-	MaxTokens         uint            `json:"max_tokens,omitempty"`
-	MaxTokensToSample uint            `json:"max_tokens_to_sample,omitempty"`
-	StopSequences     []string        `json:"stop_sequences,omitempty"`
-	Temperature       *float64        `json:"temperature,omitempty"`
-	TopP              float64         `json:"top_p,omitempty"`
-	TopK              int             `json:"top_k,omitempty"`
-	//ClaudeMetadata    `json:"metadata,omitempty"`
-	Stream     bool      `json:"stream,omitempty"`
-	Tools      any       `json:"tools,omitempty"`
-	ToolChoice any       `json:"tool_choice,omitempty"`
-	Thinking   *Thinking `json:"thinking,omitempty"`
-}
-
-type Thinking struct {
-	Type         string `json:"type"`
-	BudgetTokens *int   `json:"budget_tokens,omitempty"`
-}
-
-func (c *Thinking) GetBudgetTokens() int {
-	if c.BudgetTokens == nil {
-		return 0
-	}
-	return *c.BudgetTokens
-}
-
-func (c *ClaudeRequest) IsStringSystem() bool {
-	_, ok := c.System.(string)
-	return ok
-}
-
-func (c *ClaudeRequest) GetStringSystem() string {
-	if c.IsStringSystem() {
-		return c.System.(string)
-	}
-	return ""
-}
-
-func (c *ClaudeRequest) SetStringSystem(system string) {
-	c.System = system
-}
-
-func (c *ClaudeRequest) ParseSystem() []ClaudeMediaMessage {
-	mediaContent, _ := common.Any2Type[[]ClaudeMediaMessage](c.System)
-	return mediaContent
-}
-
-type ClaudeError struct {
-	Type    string `json:"type,omitempty"`
-	Message string `json:"message,omitempty"`
-}
-
-type ClaudeErrorWithStatusCode struct {
-	Error      ClaudeError `json:"error"`
-	StatusCode int         `json:"status_code"`
-	LocalError bool
-}
-
-type ClaudeResponse struct {
-	Id           string               `json:"id,omitempty"`
-	Type         string               `json:"type"`
-	Role         string               `json:"role,omitempty"`
-	Content      []ClaudeMediaMessage `json:"content,omitempty"`
-	Completion   string               `json:"completion,omitempty"`
-	StopReason   string               `json:"stop_reason,omitempty"`
-	Model        string               `json:"model,omitempty"`
-	Error        *ClaudeError         `json:"error,omitempty"`
-	Usage        *ClaudeUsage         `json:"usage,omitempty"`
-	Index        *int                 `json:"index,omitempty"`
-	ContentBlock *ClaudeMediaMessage  `json:"content_block,omitempty"`
-	Delta        *ClaudeMediaMessage  `json:"delta,omitempty"`
-	Message      *ClaudeMediaMessage  `json:"message,omitempty"`
-}
-
-// set index
-func (c *ClaudeResponse) SetIndex(i int) {
-	c.Index = &i
-}
-
-// get index
-func (c *ClaudeResponse) GetIndex() int {
-	if c.Index == nil {
-		return 0
-	}
-	return *c.Index
-}
-
-type ClaudeUsage struct {
-	InputTokens              int `json:"input_tokens"`
-	CacheCreationInputTokens int `json:"cache_creation_input_tokens"`
-	CacheReadInputTokens     int `json:"cache_read_input_tokens"`
-	OutputTokens             int `json:"output_tokens"`
-}
--- a/dto/dalle.go
+++ b/dto/dalle.go
@@ -1,29 +1,20 @@
 package dto

-import "encoding/json"
-
 type ImageRequest struct {
-	Model          string          `json:"model"`
-	Prompt         string          `json:"prompt" binding:"required"`
-	N              int             `json:"n,omitempty"`
-	Size           string          `json:"size,omitempty"`
-	Quality        string          `json:"quality,omitempty"`
-	ResponseFormat string          `json:"response_format,omitempty"`
-	Style          string          `json:"style,omitempty"`
-	User           string          `json:"user,omitempty"`
-	ExtraFields    json.RawMessage `json:"extra_fields,omitempty"`
-	Background     string          `json:"background,omitempty"`
-	Moderation     string          `json:"moderation,omitempty"`
-	OutputFormat   string          `json:"output_format,omitempty"`
-	Watermark      *bool           `json:"watermark,omitempty"`
+	Model          string `json:"model"`
+	Prompt         string `json:"prompt" binding:"required"`
+	N              int    `json:"n,omitempty"`
+	Size           string `json:"size,omitempty"`
+	Quality        string `json:"quality,omitempty"`
+	ResponseFormat string `json:"response_format,omitempty"`
+	Style          string `json:"style,omitempty"`
+	User           string `json:"user,omitempty"`
 }

 type ImageResponse struct {
-	Data    []ImageData `json:"data"`
-	Created int64       `json:"created"`
-}
-type ImageData struct {
-	Url           string `json:"url"`
-	B64Json       string `json:"b64_json"`
-	RevisedPrompt string `json:"revised_prompt"`
+	Created int `json:"created"`
+	Data    []struct {
+		Url     string `json:"url"`
+		B64Json string `json:"b64_json"`
+	}
 }
--- a/dto/embedding.go
+++ b/dto/embedding.go
@@ -1,57 +0,0 @@
-package dto
-
-type EmbeddingOptions struct {
-	Seed             int      `json:"seed,omitempty"`
-	Temperature      *float64 `json:"temperature,omitempty"`
-	TopK             int      `json:"top_k,omitempty"`
-	TopP             *float64 `json:"top_p,omitempty"`
-	FrequencyPenalty *float64 `json:"frequency_penalty,omitempty"`
-	PresencePenalty  *float64 `json:"presence_penalty,omitempty"`
-	NumPredict       int      `json:"num_predict,omitempty"`
-	NumCtx           int      `json:"num_ctx,omitempty"`
-}
-
-type EmbeddingRequest struct {
-	Model            string   `json:"model"`
-	Input            any      `json:"input"`
-	EncodingFormat   string   `json:"encoding_format,omitempty"`
-	Dimensions       int      `json:"dimensions,omitempty"`
-	User             string   `json:"user,omitempty"`
-	Seed             float64  `json:"seed,omitempty"`
-	Temperature      *float64 `json:"temperature,omitempty"`
-	TopP             float64  `json:"top_p,omitempty"`
-	FrequencyPenalty float64  `json:"frequency_penalty,omitempty"`
-	PresencePenalty  float64  `json:"presence_penalty,omitempty"`
-}
-
-func (r EmbeddingRequest) ParseInput() []string {
-	if r.Input == nil {
-		return nil
-	}
-	var input []string
-	switch r.Input.(type) {
-	case string:
-		input = []string{r.Input.(string)}
-	case []any:
-		input = make([]string, 0, len(r.Input.([]any)))
-		for _, item := range r.Input.([]any) {
-			if str, ok := item.(string); ok {
-				input = append(input, str)
-			}
-		}
-	}
-	return input
-}
-
-type EmbeddingResponseItem struct {
-	Object    string    `json:"object"`
-	Index     int       `json:"index"`
-	Embedding []float64 `json:"embedding"`
-}
-
-type EmbeddingResponse struct {
-	Object string                  `json:"object"`
-	Data   []EmbeddingResponseItem `json:"data"`
-	Model  string                  `json:"model"`
-	Usage  `json:"usage"`
-}
--- a/dto/file_data.go
+++ b/dto/file_data.go
@@ -1,8 +0,0 @@
-package dto
-
-type LocalFileData struct {
-	MimeType   string
-	Base64Data string
-	Url        string
-	Size       int64
-}
--- a/dto/midjourney.go
+++ b/dto/midjourney.go
@@ -33,12 +33,6 @@ type MidjourneyResponse struct {
 	Result      string      `json:"result"`
 }

-type MidjourneyUploadResponse struct {
-	Code        int      `json:"code"`
-	Description string   `json:"description"`
-	Result      []string `json:"result"`
-}
-
 type MidjourneyResponseWithStatusCode struct {
 	StatusCode int `json:"statusCode"`
 	Response   MidjourneyResponse
--- a/dto/notify.go
+++ b/dto/notify.go
@@ -1,25 +0,0 @@
-package dto
-
-type Notify struct {
-	Type    string        `json:"type"`
-	Title   string        `json:"title"`
-	Content string        `json:"content"`
-	Values  []interface{} `json:"values"`
-}
-
-const ContentValueParam = "{{value}}"
-
-const (
-	NotifyTypeQuotaExceed   = "quota_exceed"
-	NotifyTypeChannelUpdate = "channel_update"
-	NotifyTypeChannelTest   = "channel_test"
-)
-
-func NewNotify(t string, title string, content string, values []interface{}) Notify {
-	return Notify{
-		Type:    t,
-		Title:   title,
-		Content: content,
-		Values:  values,
-	}
-}
--- a/dto/openai_request.go
+++ b/dto/openai_request.go
@@ -1,649 +0,0 @@
-package dto
-
-import (
-	"encoding/json"
-	"one-api/common"
-	"strings"
-)
-
-type ResponseFormat struct {
-	Type       string            `json:"type,omitempty"`
-	JsonSchema *FormatJsonSchema `json:"json_schema,omitempty"`
-}
-
-type FormatJsonSchema struct {
-	Description string `json:"description,omitempty"`
-	Name        string `json:"name"`
-	Schema      any    `json:"schema,omitempty"`
-	Strict      any    `json:"strict,omitempty"`
-}
-
-type GeneralOpenAIRequest struct {
-	Model               string            `json:"model,omitempty"`
-	Messages            []Message         `json:"messages,omitempty"`
-	Prompt              any               `json:"prompt,omitempty"`
-	Prefix              any               `json:"prefix,omitempty"`
-	Suffix              any               `json:"suffix,omitempty"`
-	Stream              bool              `json:"stream,omitempty"`
-	StreamOptions       *StreamOptions    `json:"stream_options,omitempty"`
-	MaxTokens           uint              `json:"max_tokens,omitempty"`
-	MaxCompletionTokens uint              `json:"max_completion_tokens,omitempty"`
-	ReasoningEffort     string            `json:"reasoning_effort,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"`
-	Instruction         string            `json:"instruction,omitempty"`
-	Size                string            `json:"size,omitempty"`
-	Functions           json.RawMessage   `json:"functions,omitempty"`
-	FrequencyPenalty    float64           `json:"frequency_penalty,omitempty"`
-	PresencePenalty     float64           `json:"presence_penalty,omitempty"`
-	ResponseFormat      *ResponseFormat   `json:"response_format,omitempty"`
-	EncodingFormat      json.RawMessage   `json:"encoding_format,omitempty"`
-	Seed                float64           `json:"seed,omitempty"`
-	ParallelTooCalls    *bool             `json:"parallel_tool_calls,omitempty"`
-	Tools               []ToolCallRequest `json:"tools,omitempty"`
-	ToolChoice          any               `json:"tool_choice,omitempty"`
-	User                string            `json:"user,omitempty"`
-	LogProbs            bool              `json:"logprobs,omitempty"`
-	TopLogProbs         int               `json:"top_logprobs,omitempty"`
-	Dimensions          int               `json:"dimensions,omitempty"`
-	Modalities          json.RawMessage   `json:"modalities,omitempty"`
-	Audio               json.RawMessage   `json:"audio,omitempty"`
-	EnableThinking      any               `json:"enable_thinking,omitempty"` // ali
-	THINKING            json.RawMessage   `json:"thinking,omitempty"`        // doubao
-	ExtraBody           json.RawMessage   `json:"extra_body,omitempty"`
-	WebSearchOptions    *WebSearchOptions `json:"web_search_options,omitempty"`
-	// OpenRouter Params
-	Usage     json.RawMessage `json:"usage,omitempty"`
-	Reasoning json.RawMessage `json:"reasoning,omitempty"`
-	// Ali Qwen Params
-	VlHighResolutionImages json.RawMessage `json:"vl_high_resolution_images,omitempty"`
-}
-
-func (r *GeneralOpenAIRequest) ToMap() map[string]any {
-	result := make(map[string]any)
-	data, _ := common.EncodeJson(r)
-	_ = common.DecodeJson(data, &result)
-	return result
-}
-
-type ToolCallRequest struct {
-	ID       string          `json:"id,omitempty"`
-	Type     string          `json:"type"`
-	Function FunctionRequest `json:"function"`
-}
-
-type FunctionRequest struct {
-	Description string `json:"description,omitempty"`
-	Name        string `json:"name"`
-	Parameters  any    `json:"parameters,omitempty"`
-	Arguments   string `json:"arguments,omitempty"`
-}
-
-type StreamOptions struct {
-	IncludeUsage bool `json:"include_usage,omitempty"`
-}
-
-func (r *GeneralOpenAIRequest) GetMaxTokens() int {
-	return int(r.MaxTokens)
-}
-
-func (r *GeneralOpenAIRequest) ParseInput() []string {
-	if r.Input == nil {
-		return nil
-	}
-	var input []string
-	switch r.Input.(type) {
-	case string:
-		input = []string{r.Input.(string)}
-	case []any:
-		input = make([]string, 0, len(r.Input.([]any)))
-		for _, item := range r.Input.([]any) {
-			if str, ok := item.(string); ok {
-				input = append(input, str)
-			}
-		}
-	}
-	return input
-}
-
-type Message struct {
-	Role             string          `json:"role"`
-	Content          any             `json:"content"`
-	Name             *string         `json:"name,omitempty"`
-	Prefix           *bool           `json:"prefix,omitempty"`
-	ReasoningContent string          `json:"reasoning_content,omitempty"`
-	Reasoning        string          `json:"reasoning,omitempty"`
-	ToolCalls        json.RawMessage `json:"tool_calls,omitempty"`
-	ToolCallId       string          `json:"tool_call_id,omitempty"`
-	parsedContent    []MediaContent
-	//parsedStringContent *string
-}
-
-type MediaContent struct {
-	Type       string `json:"type"`
-	Text       string `json:"text,omitempty"`
-	ImageUrl   any    `json:"image_url,omitempty"`
-	InputAudio any    `json:"input_audio,omitempty"`
-	File       any    `json:"file,omitempty"`
-	VideoUrl   any    `json:"video_url,omitempty"`
-	// OpenRouter Params
-	CacheControl json.RawMessage `json:"cache_control,omitempty"`
-}
-
-func (m *MediaContent) GetImageMedia() *MessageImageUrl {
-	if m.ImageUrl != nil {
-		if _, ok := m.ImageUrl.(*MessageImageUrl); ok {
-			return m.ImageUrl.(*MessageImageUrl)
-		}
-		if itemMap, ok := m.ImageUrl.(map[string]any); ok {
-			out := &MessageImageUrl{
-				Url:      common.Interface2String(itemMap["url"]),
-				Detail:   common.Interface2String(itemMap["detail"]),
-				MimeType: common.Interface2String(itemMap["mime_type"]),
-			}
-			return out
-		}
-	}
-	return nil
-}
-
-func (m *MediaContent) GetInputAudio() *MessageInputAudio {
-	if m.InputAudio != nil {
-		if _, ok := m.InputAudio.(*MessageInputAudio); ok {
-			return m.InputAudio.(*MessageInputAudio)
-		}
-		if itemMap, ok := m.InputAudio.(map[string]any); ok {
-			out := &MessageInputAudio{
-				Data:   common.Interface2String(itemMap["data"]),
-				Format: common.Interface2String(itemMap["format"]),
-			}
-			return out
-		}
-	}
-	return nil
-}
-
-func (m *MediaContent) GetFile() *MessageFile {
-	if m.File != nil {
-		if _, ok := m.File.(*MessageFile); ok {
-			return m.File.(*MessageFile)
-		}
-		if itemMap, ok := m.File.(map[string]any); ok {
-			out := &MessageFile{
-				FileName: common.Interface2String(itemMap["file_name"]),
-				FileData: common.Interface2String(itemMap["file_data"]),
-				FileId:   common.Interface2String(itemMap["file_id"]),
-			}
-			return out
-		}
-	}
-	return nil
-}
-
-type MessageImageUrl struct {
-	Url      string `json:"url"`
-	Detail   string `json:"detail"`
-	MimeType string
-}
-
-func (m *MessageImageUrl) IsRemoteImage() bool {
-	return strings.HasPrefix(m.Url, "http")
-}
-
-type MessageInputAudio struct {
-	Data   string `json:"data"` //base64
-	Format string `json:"format"`
-}
-
-type MessageFile struct {
-	FileName string `json:"filename,omitempty"`
-	FileData string `json:"file_data,omitempty"`
-	FileId   string `json:"file_id,omitempty"`
-}
-
-type MessageVideoUrl struct {
-	Url string `json:"url"`
-}
-
-const (
-	ContentTypeText       = "text"
-	ContentTypeImageURL   = "image_url"
-	ContentTypeInputAudio = "input_audio"
-	ContentTypeFile       = "file"
-	ContentTypeVideoUrl   = "video_url" // 阿里百炼视频识别
-)
-
-func (m *Message) GetPrefix() bool {
-	if m.Prefix == nil {
-		return false
-	}
-	return *m.Prefix
-}
-
-func (m *Message) SetPrefix(prefix bool) {
-	m.Prefix = &prefix
-}
-
-func (m *Message) ParseToolCalls() []ToolCallRequest {
-	if m.ToolCalls == nil {
-		return nil
-	}
-	var toolCalls []ToolCallRequest
-	if err := json.Unmarshal(m.ToolCalls, &toolCalls); err == nil {
-		return toolCalls
-	}
-	return toolCalls
-}
-
-func (m *Message) SetToolCalls(toolCalls any) {
-	toolCallsJson, _ := json.Marshal(toolCalls)
-	m.ToolCalls = toolCallsJson
-}
-
-func (m *Message) StringContent() string {
-	switch m.Content.(type) {
-	case string:
-		return m.Content.(string)
-	case []any:
-		var contentStr string
-		for _, contentItem := range m.Content.([]any) {
-			contentMap, ok := contentItem.(map[string]any)
-			if !ok {
-				continue
-			}
-			if contentMap["type"] == ContentTypeText {
-				if subStr, ok := contentMap["text"].(string); ok {
-					contentStr += subStr
-				}
-			}
-		}
-		return contentStr
-	}
-
-	return ""
-}
-
-func (m *Message) SetNullContent() {
-	m.Content = nil
-	m.parsedContent = nil
-}
-
-func (m *Message) SetStringContent(content string) {
-	m.Content = content
-	m.parsedContent = nil
-}
-
-func (m *Message) SetMediaContent(content []MediaContent) {
-	m.Content = content
-	m.parsedContent = content
-}
-
-func (m *Message) IsStringContent() bool {
-	_, ok := m.Content.(string)
-	if ok {
-		return true
-	}
-	return false
-}
-
-func (m *Message) ParseContent() []MediaContent {
-	if m.Content == nil {
-		return nil
-	}
-	if len(m.parsedContent) > 0 {
-		return m.parsedContent
-	}
-
-	var contentList []MediaContent
-	// 先尝试解析为字符串
-	content, ok := m.Content.(string)
-	if ok {
-		contentList = []MediaContent{{
-			Type: ContentTypeText,
-			Text: content,
-		}}
-		m.parsedContent = contentList
-		return contentList
-	}
-
-	// 尝试解析为数组
-	//var arrayContent []map[string]interface{}
-
-	arrayContent, ok := m.Content.([]any)
-	if !ok {
-		return contentList
-	}
-
-	for _, contentItemAny := range arrayContent {
-		mediaItem, ok := contentItemAny.(MediaContent)
-		if ok {
-			contentList = append(contentList, mediaItem)
-			continue
-		}
-
-		contentItem, ok := contentItemAny.(map[string]any)
-		if !ok {
-			continue
-		}
-		contentType, ok := contentItem["type"].(string)
-		if !ok {
-			continue
-		}
-
-		switch contentType {
-		case ContentTypeText:
-			if text, ok := contentItem["text"].(string); ok {
-				contentList = append(contentList, MediaContent{
-					Type: ContentTypeText,
-					Text: text,
-				})
-			}
-
-		case ContentTypeImageURL:
-			imageUrl := contentItem["image_url"]
-			temp := &MessageImageUrl{
-				Detail: "high",
-			}
-			switch v := imageUrl.(type) {
-			case string:
-				temp.Url = v
-			case map[string]interface{}:
-				url, ok1 := v["url"].(string)
-				detail, ok2 := v["detail"].(string)
-				if ok2 {
-					temp.Detail = detail
-				}
-				if ok1 {
-					temp.Url = url
-				}
-			}
-			contentList = append(contentList, MediaContent{
-				Type:     ContentTypeImageURL,
-				ImageUrl: temp,
-			})
-
-		case ContentTypeInputAudio:
-			if audioData, ok := contentItem["input_audio"].(map[string]interface{}); ok {
-				data, ok1 := audioData["data"].(string)
-				format, ok2 := audioData["format"].(string)
-				if ok1 && ok2 {
-					temp := &MessageInputAudio{
-						Data:   data,
-						Format: format,
-					}
-					contentList = append(contentList, MediaContent{
-						Type:       ContentTypeInputAudio,
-						InputAudio: temp,
-					})
-				}
-			}
-		case ContentTypeFile:
-			if fileData, ok := contentItem["file"].(map[string]interface{}); ok {
-				fileId, ok3 := fileData["file_id"].(string)
-				if ok3 {
-					contentList = append(contentList, MediaContent{
-						Type: ContentTypeFile,
-						File: &MessageFile{
-							FileId: fileId,
-						},
-					})
-				} else {
-					fileName, ok1 := fileData["filename"].(string)
-					fileDataStr, ok2 := fileData["file_data"].(string)
-					if ok1 && ok2 {
-						contentList = append(contentList, MediaContent{
-							Type: ContentTypeFile,
-							File: &MessageFile{
-								FileName: fileName,
-								FileData: fileDataStr,
-							},
-						})
-					}
-				}
-			}
-		case ContentTypeVideoUrl:
-			if videoUrl, ok := contentItem["video_url"].(string); ok {
-				contentList = append(contentList, MediaContent{
-					Type: ContentTypeVideoUrl,
-					VideoUrl: &MessageVideoUrl{
-						Url: videoUrl,
-					},
-				})
-			}
-		}
-	}
-
-	if len(contentList) > 0 {
-		m.parsedContent = contentList
-	}
-	return contentList
-}
-
-// old code
-/*func (m *Message) StringContent() string {
-	if m.parsedStringContent != nil {
-		return *m.parsedStringContent
-	}
-
-	var stringContent string
-	if err := json.Unmarshal(m.Content, &stringContent); err == nil {
-		m.parsedStringContent = &stringContent
-		return stringContent
-	}
-
-	contentStr := new(strings.Builder)
-	arrayContent := m.ParseContent()
-	for _, content := range arrayContent {
-		if content.Type == ContentTypeText {
-			contentStr.WriteString(content.Text)
-		}
-	}
-	stringContent = contentStr.String()
-	m.parsedStringContent = &stringContent
-
-	return stringContent
-}
-
-func (m *Message) SetNullContent() {
-	m.Content = nil
-	m.parsedStringContent = nil
-	m.parsedContent = nil
-}
-
-func (m *Message) SetStringContent(content string) {
-	jsonContent, _ := json.Marshal(content)
-	m.Content = jsonContent
-	m.parsedStringContent = &content
-	m.parsedContent = nil
-}
-
-func (m *Message) SetMediaContent(content []MediaContent) {
-	jsonContent, _ := json.Marshal(content)
-	m.Content = jsonContent
-	m.parsedContent = nil
-	m.parsedStringContent = nil
-}
-
-func (m *Message) IsStringContent() bool {
-	if m.parsedStringContent != nil {
-		return true
-	}
-	var stringContent string
-	if err := json.Unmarshal(m.Content, &stringContent); err == nil {
-		m.parsedStringContent = &stringContent
-		return true
-	}
-	return false
-}
-
-func (m *Message) ParseContent() []MediaContent {
-	if m.parsedContent != nil {
-		return m.parsedContent
-	}
-
-	var contentList []MediaContent
-
-	// 先尝试解析为字符串
-	var stringContent string
-	if err := json.Unmarshal(m.Content, &stringContent); err == nil {
-		contentList = []MediaContent{{
-			Type: ContentTypeText,
-			Text: stringContent,
-		}}
-		m.parsedContent = contentList
-		return contentList
-	}
-
-	// 尝试解析为数组
-	var arrayContent []map[string]interface{}
-	if err := json.Unmarshal(m.Content, &arrayContent); err == nil {
-		for _, contentItem := range arrayContent {
-			contentType, ok := contentItem["type"].(string)
-			if !ok {
-				continue
-			}
-
-			switch contentType {
-			case ContentTypeText:
-				if text, ok := contentItem["text"].(string); ok {
-					contentList = append(contentList, MediaContent{
-						Type: ContentTypeText,
-						Text: text,
-					})
-				}
-
-			case ContentTypeImageURL:
-				imageUrl := contentItem["image_url"]
-				temp := &MessageImageUrl{
-					Detail: "high",
-				}
-				switch v := imageUrl.(type) {
-				case string:
-					temp.Url = v
-				case map[string]interface{}:
-					url, ok1 := v["url"].(string)
-					detail, ok2 := v["detail"].(string)
-					if ok2 {
-						temp.Detail = detail
-					}
-					if ok1 {
-						temp.Url = url
-					}
-				}
-				contentList = append(contentList, MediaContent{
-					Type:     ContentTypeImageURL,
-					ImageUrl: temp,
-				})
-
-			case ContentTypeInputAudio:
-				if audioData, ok := contentItem["input_audio"].(map[string]interface{}); ok {
-					data, ok1 := audioData["data"].(string)
-					format, ok2 := audioData["format"].(string)
-					if ok1 && ok2 {
-						temp := &MessageInputAudio{
-							Data:   data,
-							Format: format,
-						}
-						contentList = append(contentList, MediaContent{
-							Type:       ContentTypeInputAudio,
-							InputAudio: temp,
-						})
-					}
-				}
-			case ContentTypeFile:
-				if fileData, ok := contentItem["file"].(map[string]interface{}); ok {
-					fileId, ok3 := fileData["file_id"].(string)
-					if ok3 {
-						contentList = append(contentList, MediaContent{
-							Type: ContentTypeFile,
-							File: &MessageFile{
-								FileId: fileId,
-							},
-						})
-					} else {
-						fileName, ok1 := fileData["filename"].(string)
-						fileDataStr, ok2 := fileData["file_data"].(string)
-						if ok1 && ok2 {
-							contentList = append(contentList, MediaContent{
-								Type: ContentTypeFile,
-								File: &MessageFile{
-									FileName: fileName,
-									FileData: fileDataStr,
-								},
-							})
-						}
-					}
-				}
-			case ContentTypeVideoUrl:
-				if videoUrl, ok := contentItem["video_url"].(string); ok {
-					contentList = append(contentList, MediaContent{
-						Type: ContentTypeVideoUrl,
-						VideoUrl: &MessageVideoUrl{
-							Url: videoUrl,
-						},
-					})
-				}
-			}
-		}
-	}
-
-	if len(contentList) > 0 {
-		m.parsedContent = contentList
-	}
-	return contentList
-}*/
-
-type WebSearchOptions struct {
-	SearchContextSize string          `json:"search_context_size,omitempty"`
-	UserLocation      json.RawMessage `json:"user_location,omitempty"`
-}
-
-type OpenAIResponsesRequest struct {
-	Model              string               `json:"model"`
-	Input              json.RawMessage      `json:"input,omitempty"`
-	Include            json.RawMessage      `json:"include,omitempty"`
-	Instructions       json.RawMessage      `json:"instructions,omitempty"`
-	MaxOutputTokens    uint                 `json:"max_output_tokens,omitempty"`
-	Metadata           json.RawMessage      `json:"metadata,omitempty"`
-	ParallelToolCalls  bool                 `json:"parallel_tool_calls,omitempty"`
-	PreviousResponseID string               `json:"previous_response_id,omitempty"`
-	Reasoning          *Reasoning           `json:"reasoning,omitempty"`
-	ServiceTier        string               `json:"service_tier,omitempty"`
-	Store              bool                 `json:"store,omitempty"`
-	Stream             bool                 `json:"stream,omitempty"`
-	Temperature        float64              `json:"temperature,omitempty"`
-	Text               json.RawMessage      `json:"text,omitempty"`
-	ToolChoice         json.RawMessage      `json:"tool_choice,omitempty"`
-	Tools              []ResponsesToolsCall `json:"tools,omitempty"`
-	TopP               float64              `json:"top_p,omitempty"`
-	Truncation         string               `json:"truncation,omitempty"`
-	User               string               `json:"user,omitempty"`
-}
-
-type Reasoning struct {
-	Effort  string `json:"effort,omitempty"`
-	Summary string `json:"summary,omitempty"`
-}
-
-type ResponsesToolsCall struct {
-	Type string `json:"type"`
-	// Web Search
-	UserLocation      json.RawMessage `json:"user_location,omitempty"`
-	SearchContextSize string          `json:"search_context_size,omitempty"`
-	// File Search
-	VectorStoreIds []string        `json:"vector_store_ids,omitempty"`
-	MaxNumResults  uint            `json:"max_num_results,omitempty"`
-	Filters        json.RawMessage `json:"filters,omitempty"`
-	// Computer Use
-	DisplayWidth  uint   `json:"display_width,omitempty"`
-	DisplayHeight uint   `json:"display_height,omitempty"`
-	Environment   string `json:"environment,omitempty"`
-	// Function
-	Name        string          `json:"name,omitempty"`
-	Description string          `json:"description,omitempty"`
-	Parameters  json.RawMessage `json:"parameters,omitempty"`
-}
--- a/dto/openai_response.go
+++ b/dto/openai_response.go
@@ -1,262 +0,0 @@
-package dto
-
-import "encoding/json"
-
-type SimpleResponse struct {
-	Usage `json:"usage"`
-	Error *OpenAIError `json:"error"`
-}
-
-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"`
-	FinishReason string `json:"finish_reason"`
-}
-
-type OpenAITextResponse struct {
-	Id      string                     `json:"id"`
-	Model   string                     `json:"model"`
-	Object  string                     `json:"object"`
-	Created any                        `json:"created"`
-	Choices []OpenAITextResponseChoice `json:"choices"`
-	Error   *OpenAIError               `json:"error,omitempty"`
-	Usage   `json:"usage"`
-}
-
-type OpenAIEmbeddingResponseItem struct {
-	Object    string    `json:"object"`
-	Index     int       `json:"index"`
-	Embedding []float64 `json:"embedding"`
-}
-
-type OpenAIEmbeddingResponse struct {
-	Object string                        `json:"object"`
-	Data   []OpenAIEmbeddingResponseItem `json:"data"`
-	Model  string                        `json:"model"`
-	Usage  `json:"usage"`
-}
-
-type ChatCompletionsStreamResponseChoice struct {
-	Delta        ChatCompletionsStreamResponseChoiceDelta `json:"delta,omitempty"`
-	Logprobs     *any                                     `json:"logprobs"`
-	FinishReason *string                                  `json:"finish_reason"`
-	Index        int                                      `json:"index"`
-}
-
-type ChatCompletionsStreamResponseChoiceDelta struct {
-	Content          *string            `json:"content,omitempty"`
-	ReasoningContent *string            `json:"reasoning_content,omitempty"`
-	Reasoning        *string            `json:"reasoning,omitempty"`
-	Role             string             `json:"role,omitempty"`
-	ToolCalls        []ToolCallResponse `json:"tool_calls,omitempty"`
-}
-
-func (c *ChatCompletionsStreamResponseChoiceDelta) SetContentString(s string) {
-	c.Content = &s
-}
-
-func (c *ChatCompletionsStreamResponseChoiceDelta) GetContentString() string {
-	if c.Content == nil {
-		return ""
-	}
-	return *c.Content
-}
-
-func (c *ChatCompletionsStreamResponseChoiceDelta) GetReasoningContent() string {
-	if c.ReasoningContent == nil && c.Reasoning == nil {
-		return ""
-	}
-	if c.ReasoningContent != nil {
-		return *c.ReasoningContent
-	}
-	return *c.Reasoning
-}
-
-func (c *ChatCompletionsStreamResponseChoiceDelta) SetReasoningContent(s string) {
-	c.ReasoningContent = &s
-	c.Reasoning = &s
-}
-
-type ToolCallResponse struct {
-	// Index is not nil only in chat completion chunk object
-	Index    *int             `json:"index,omitempty"`
-	ID       string           `json:"id,omitempty"`
-	Type     any              `json:"type"`
-	Function FunctionResponse `json:"function"`
-}
-
-func (c *ToolCallResponse) SetIndex(i int) {
-	c.Index = &i
-}
-
-type FunctionResponse struct {
-	Description string `json:"description,omitempty"`
-	Name        string `json:"name,omitempty"`
-	// call function with arguments in JSON format
-	Parameters any    `json:"parameters,omitempty"` // request
-	Arguments  string `json:"arguments"`            // response
-}
-
-type ChatCompletionsStreamResponse struct {
-	Id                string                                `json:"id"`
-	Object            string                                `json:"object"`
-	Created           int64                                 `json:"created"`
-	Model             string                                `json:"model"`
-	SystemFingerprint *string                               `json:"system_fingerprint"`
-	Choices           []ChatCompletionsStreamResponseChoice `json:"choices"`
-	Usage             *Usage                                `json:"usage"`
-}
-
-func (c *ChatCompletionsStreamResponse) IsToolCall() bool {
-	if len(c.Choices) == 0 {
-		return false
-	}
-	return len(c.Choices[0].Delta.ToolCalls) > 0
-}
-
-func (c *ChatCompletionsStreamResponse) GetFirstToolCall() *ToolCallResponse {
-	if c.IsToolCall() {
-		return &c.Choices[0].Delta.ToolCalls[0]
-	}
-	return nil
-}
-
-func (c *ChatCompletionsStreamResponse) Copy() *ChatCompletionsStreamResponse {
-	choices := make([]ChatCompletionsStreamResponseChoice, len(c.Choices))
-	copy(choices, c.Choices)
-	return &ChatCompletionsStreamResponse{
-		Id:                c.Id,
-		Object:            c.Object,
-		Created:           c.Created,
-		Model:             c.Model,
-		SystemFingerprint: c.SystemFingerprint,
-		Choices:           choices,
-		Usage:             c.Usage,
-	}
-}
-
-func (c *ChatCompletionsStreamResponse) GetSystemFingerprint() string {
-	if c.SystemFingerprint == nil {
-		return ""
-	}
-	return *c.SystemFingerprint
-}
-
-func (c *ChatCompletionsStreamResponse) SetSystemFingerprint(s string) {
-	c.SystemFingerprint = &s
-}
-
-type ChatCompletionsStreamResponseSimple struct {
-	Choices []ChatCompletionsStreamResponseChoice `json:"choices"`
-	Usage   *Usage                                `json:"usage"`
-}
-
-type CompletionsStreamResponse struct {
-	Choices []struct {
-		Text         string `json:"text"`
-		FinishReason string `json:"finish_reason"`
-	} `json:"choices"`
-}
-
-type Usage struct {
-	PromptTokens         int `json:"prompt_tokens"`
-	CompletionTokens     int `json:"completion_tokens"`
-	TotalTokens          int `json:"total_tokens"`
-	PromptCacheHitTokens int `json:"prompt_cache_hit_tokens,omitempty"`
-
-	PromptTokensDetails    InputTokenDetails  `json:"prompt_tokens_details"`
-	CompletionTokenDetails OutputTokenDetails `json:"completion_tokens_details"`
-	InputTokens            int                `json:"input_tokens"`
-	OutputTokens           int                `json:"output_tokens"`
-	InputTokensDetails     *InputTokenDetails `json:"input_tokens_details"`
-	// OpenRouter Params
-	Cost float64 `json:"cost,omitempty"`
-}
-
-type InputTokenDetails struct {
-	CachedTokens         int `json:"cached_tokens"`
-	CachedCreationTokens int `json:"-"`
-	TextTokens           int `json:"text_tokens"`
-	AudioTokens          int `json:"audio_tokens"`
-	ImageTokens          int `json:"image_tokens"`
-}
-
-type OutputTokenDetails struct {
-	TextTokens      int `json:"text_tokens"`
-	AudioTokens     int `json:"audio_tokens"`
-	ReasoningTokens int `json:"reasoning_tokens"`
-}
-
-type OpenAIResponsesResponse struct {
-	ID                 string               `json:"id"`
-	Object             string               `json:"object"`
-	CreatedAt          int                  `json:"created_at"`
-	Status             string               `json:"status"`
-	Error              *OpenAIError         `json:"error,omitempty"`
-	IncompleteDetails  *IncompleteDetails   `json:"incomplete_details,omitempty"`
-	Instructions       string               `json:"instructions"`
-	MaxOutputTokens    int                  `json:"max_output_tokens"`
-	Model              string               `json:"model"`
-	Output             []ResponsesOutput    `json:"output"`
-	ParallelToolCalls  bool                 `json:"parallel_tool_calls"`
-	PreviousResponseID string               `json:"previous_response_id"`
-	Reasoning          *Reasoning           `json:"reasoning"`
-	Store              bool                 `json:"store"`
-	Temperature        float64              `json:"temperature"`
-	ToolChoice         string               `json:"tool_choice"`
-	Tools              []ResponsesToolsCall `json:"tools"`
-	TopP               float64              `json:"top_p"`
-	Truncation         string               `json:"truncation"`
-	Usage              *Usage               `json:"usage"`
-	User               json.RawMessage      `json:"user"`
-	Metadata           json.RawMessage      `json:"metadata"`
-}
-
-type IncompleteDetails struct {
-	Reasoning string `json:"reasoning"`
-}
-
-type ResponsesOutput struct {
-	Type    string                   `json:"type"`
-	ID      string                   `json:"id"`
-	Status  string                   `json:"status"`
-	Role    string                   `json:"role"`
-	Content []ResponsesOutputContent `json:"content"`
-}
-
-type ResponsesOutputContent struct {
-	Type        string        `json:"type"`
-	Text        string        `json:"text"`
-	Annotations []interface{} `json:"annotations"`
-}
-
-const (
-	BuildInToolWebSearchPreview = "web_search_preview"
-	BuildInToolFileSearch       = "file_search"
-)
-
-const (
-	BuildInCallWebSearchCall = "web_search_call"
-)
-
-const (
-	ResponsesOutputTypeItemAdded = "response.output_item.added"
-	ResponsesOutputTypeItemDone  = "response.output_item.done"
-)
-
-// ResponsesStreamResponse 用于处理 /v1/responses 流式响应
-type ResponsesStreamResponse struct {
-	Type     string                   `json:"type"`
-	Response *OpenAIResponsesResponse `json:"response,omitempty"`
-	Delta    string                   `json:"delta,omitempty"`
-	Item     *ResponsesOutput         `json:"item,omitempty"`
-}
--- a/dto/playground.go
+++ b/dto/playground.go
@@ -1,6 +0,0 @@
-package dto
-
-type PlayGroundRequest struct {
-	Model string `json:"model,omitempty"`
-	Group string `json:"group,omitempty"`
-}
--- a/dto/pricing.go
+++ b/dto/pricing.go
@@ -24,3 +24,14 @@ type OpenAIModels struct {
 	Root       string                  `json:"root"`
 	Parent     *string                 `json:"parent"`
 }
+
+type ModelPricing struct {
+	Available       bool     `json:"available"`
+	ModelName       string   `json:"model_name"`
+	QuotaType       int      `json:"quota_type"`
+	ModelRatio      float64  `json:"model_ratio"`
+	ModelPrice      float64  `json:"model_price"`
+	OwnerBy         string   `json:"owner_by"`
+	CompletionRatio float64  `json:"completion_ratio"`
+	EnableGroup     []string `json:"enable_group,omitempty"`
+}
--- a/dto/ratio_sync.go
+++ b/dto/ratio_sync.go
@@ -1,38 +0,0 @@
-package dto
-
-type UpstreamDTO struct {
-    ID       int    `json:"id,omitempty"`
-    Name     string `json:"name" binding:"required"`
-    BaseURL  string `json:"base_url" binding:"required"`
-    Endpoint string `json:"endpoint"`
-}
-
-type UpstreamRequest struct {
-    ChannelIDs []int64 `json:"channel_ids"`
-    Upstreams   []UpstreamDTO `json:"upstreams"`
-    Timeout    int     `json:"timeout"`
-}
-
-// TestResult 上游测试连通性结果
-type TestResult struct {
-    Name   string `json:"name"`
-    Status string `json:"status"`
-    Error  string `json:"error,omitempty"`
-}
-
-// DifferenceItem 差异项
-// Current 为本地值，可能为 nil
-// Upstreams 为各渠道的上游值，具体数值 / "same" / nil
-
-type DifferenceItem struct {
-    Current   interface{}            `json:"current"`
-    Upstreams map[string]interface{} `json:"upstreams"`
-    Confidence map[string]bool       `json:"confidence"`
-}
-
-type SyncableChannel struct {
-    ID      int    `json:"id"`
-    Name    string `json:"name"`
-    BaseURL string `json:"base_url"`
-    Status  int    `json:"status"`
-} 
--- a/dto/realtime.go
+++ b/dto/realtime.go
@@ -1,86 +0,0 @@
-package dto
-
-const (
-	RealtimeEventTypeError              = "error"
-	RealtimeEventTypeSessionUpdate      = "session.update"
-	RealtimeEventTypeConversationCreate = "conversation.item.create"
-	RealtimeEventTypeResponseCreate     = "response.create"
-	RealtimeEventInputAudioBufferAppend = "input_audio_buffer.append"
-)
-
-const (
-	RealtimeEventTypeResponseDone                   = "response.done"
-	RealtimeEventTypeSessionUpdated                 = "session.updated"
-	RealtimeEventTypeSessionCreated                 = "session.created"
-	RealtimeEventResponseAudioDelta                 = "response.audio.delta"
-	RealtimeEventResponseAudioTranscriptionDelta    = "response.audio_transcript.delta"
-	RealtimeEventResponseFunctionCallArgumentsDelta = "response.function_call_arguments.delta"
-	RealtimeEventResponseFunctionCallArgumentsDone  = "response.function_call_arguments.done"
-	RealtimeEventConversationItemCreated            = "conversation.item.created"
-)
-
-type RealtimeEvent struct {
-	EventId string `json:"event_id"`
-	Type    string `json:"type"`
-	//PreviousItemId string `json:"previous_item_id"`
-	Session  *RealtimeSession  `json:"session,omitempty"`
-	Item     *RealtimeItem     `json:"item,omitempty"`
-	Error    *OpenAIError      `json:"error,omitempty"`
-	Response *RealtimeResponse `json:"response,omitempty"`
-	Delta    string            `json:"delta,omitempty"`
-	Audio    string            `json:"audio,omitempty"`
-}
-
-type RealtimeResponse struct {
-	Usage *RealtimeUsage `json:"usage"`
-}
-
-type RealtimeUsage struct {
-	TotalTokens        int                `json:"total_tokens"`
-	InputTokens        int                `json:"input_tokens"`
-	OutputTokens       int                `json:"output_tokens"`
-	InputTokenDetails  InputTokenDetails  `json:"input_token_details"`
-	OutputTokenDetails OutputTokenDetails `json:"output_token_details"`
-}
-
-type RealtimeSession struct {
-	Modalities              []string                `json:"modalities"`
-	Instructions            string                  `json:"instructions"`
-	Voice                   string                  `json:"voice"`
-	InputAudioFormat        string                  `json:"input_audio_format"`
-	OutputAudioFormat       string                  `json:"output_audio_format"`
-	InputAudioTranscription InputAudioTranscription `json:"input_audio_transcription"`
-	TurnDetection           interface{}             `json:"turn_detection"`
-	Tools                   []RealTimeTool          `json:"tools"`
-	ToolChoice              string                  `json:"tool_choice"`
-	Temperature             float64                 `json:"temperature"`
-	//MaxResponseOutputTokens int                     `json:"max_response_output_tokens"`
-}
-
-type InputAudioTranscription struct {
-	Model string `json:"model"`
-}
-
-type RealTimeTool struct {
-	Type        string `json:"type"`
-	Name        string `json:"name"`
-	Description string `json:"description"`
-	Parameters  any    `json:"parameters"`
-}
-
-type RealtimeItem struct {
-	Id        string            `json:"id"`
-	Type      string            `json:"type"`
-	Status    string            `json:"status"`
-	Role      string            `json:"role"`
-	Content   []RealtimeContent `json:"content"`
-	Name      *string           `json:"name,omitempty"`
-	ToolCalls any               `json:"tool_calls,omitempty"`
-	CallId    string            `json:"call_id,omitempty"`
-}
-type RealtimeContent struct {
-	Type       string `json:"type"`
-	Text       string `json:"text,omitempty"`
-	Audio      string `json:"audio,omitempty"` // Base64-encoded audio bytes.
-	Transcript string `json:"transcript,omitempty"`
-}
--- a/dto/rerank.go
+++ b/dto/rerank.go
@@ -1,33 +0,0 @@
-package dto
-
-type RerankRequest struct {
-	Documents       []any  `json:"documents"`
-	Query           string `json:"query"`
-	Model           string `json:"model"`
-	TopN            int    `json:"top_n"`
-	ReturnDocuments *bool  `json:"return_documents,omitempty"`
-	MaxChunkPerDoc  int    `json:"max_chunk_per_doc,omitempty"`
-	OverLapTokens   int    `json:"overlap_tokens,omitempty"`
-}
-
-func (r *RerankRequest) GetReturnDocuments() bool {
-	if r.ReturnDocuments == nil {
-		return false
-	}
-	return *r.ReturnDocuments
-}
-
-type RerankResponseResult struct {
-	Document       any     `json:"document,omitempty"`
-	Index          int     `json:"index"`
-	RelevanceScore float64 `json:"relevance_score"`
-}
-
-type RerankDocument struct {
-	Text any `json:"text"`
-}
-
-type RerankResponse struct {
-	Results []RerankResponseResult `json:"results"`
-	Usage   Usage                  `json:"usage"`
-}
--- a/dto/text_request.go
+++ b/dto/text_request.go
@@ -0,0 +1,156 @@
+package dto
+
+import "encoding/json"
+
+type ResponseFormat struct {
+	Type string `json:"type,omitempty"`
+}
+
+type GeneralOpenAIRequest struct {
+	Model            string          `json:"model,omitempty"`
+	Messages         []Message       `json:"messages,omitempty"`
+	Prompt           any             `json:"prompt,omitempty"`
+	Stream           bool            `json:"stream,omitempty"`
+	MaxTokens        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"`
+	Instruction      string          `json:"instruction,omitempty"`
+	Size             string          `json:"size,omitempty"`
+	Functions        any             `json:"functions,omitempty"`
+	FrequencyPenalty float64         `json:"frequency_penalty,omitempty"`
+	PresencePenalty  float64         `json:"presence_penalty,omitempty"`
+	ResponseFormat   *ResponseFormat `json:"response_format,omitempty"`
+	Seed             float64         `json:"seed,omitempty"`
+	Tools            any             `json:"tools,omitempty"`
+	ToolChoice       any             `json:"tool_choice,omitempty"`
+	User             string          `json:"user,omitempty"`
+	LogProbs         bool            `json:"logprobs,omitempty"`
+	TopLogProbs      int             `json:"top_logprobs,omitempty"`
+}
+
+type OpenAITools struct {
+	Type     string         `json:"type"`
+	Function OpenAIFunction `json:"function"`
+}
+
+type OpenAIFunction struct {
+	Description string `json:"description,omitempty"`
+	Name        string `json:"name"`
+	Parameters  any    `json:"parameters,omitempty"`
+}
+
+func (r GeneralOpenAIRequest) GetMaxTokens() int64 {
+	return int64(r.MaxTokens)
+}
+
+func (r GeneralOpenAIRequest) ParseInput() []string {
+	if r.Input == nil {
+		return nil
+	}
+	var input []string
+	switch r.Input.(type) {
+	case string:
+		input = []string{r.Input.(string)}
+	case []any:
+		input = make([]string, 0, len(r.Input.([]any)))
+		for _, item := range r.Input.([]any) {
+			if str, ok := item.(string); ok {
+				input = append(input, str)
+			}
+		}
+	}
+	return input
+}
+
+type Message struct {
+	Role       string          `json:"role"`
+	Content    json.RawMessage `json:"content"`
+	Name       *string         `json:"name,omitempty"`
+	ToolCalls  any             `json:"tool_calls,omitempty"`
+	ToolCallId string          `json:"tool_call_id,omitempty"`
+}
+
+type MediaMessage struct {
+	Type     string `json:"type"`
+	Text     string `json:"text"`
+	ImageUrl any    `json:"image_url,omitempty"`
+}
+
+type MessageImageUrl struct {
+	Url    string `json:"url"`
+	Detail string `json:"detail"`
+}
+
+const (
+	ContentTypeText     = "text"
+	ContentTypeImageURL = "image_url"
+)
+
+func (m Message) StringContent() string {
+	var stringContent string
+	if err := json.Unmarshal(m.Content, &stringContent); err == nil {
+		return stringContent
+	}
+	return string(m.Content)
+}
+
+func (m Message) IsStringContent() bool {
+	var stringContent string
+	if err := json.Unmarshal(m.Content, &stringContent); err == nil {
+		return true
+	}
+	return false
+}
+
+func (m Message) ParseContent() []MediaMessage {
+	var contentList []MediaMessage
+	var stringContent string
+	if err := json.Unmarshal(m.Content, &stringContent); err == nil {
+		contentList = append(contentList, MediaMessage{
+			Type: ContentTypeText,
+			Text: stringContent,
+		})
+		return contentList
+	}
+	var arrayContent []json.RawMessage
+	if err := json.Unmarshal(m.Content, &arrayContent); err == nil {
+		for _, contentItem := range arrayContent {
+			var contentMap map[string]any
+			if err := json.Unmarshal(contentItem, &contentMap); err != nil {
+				continue
+			}
+			switch contentMap["type"] {
+			case ContentTypeText:
+				if subStr, ok := contentMap["text"].(string); ok {
+					contentList = append(contentList, MediaMessage{
+						Type: ContentTypeText,
+						Text: subStr,
+					})
+				}
+			case ContentTypeImageURL:
+				if subObj, ok := contentMap["image_url"].(map[string]any); ok {
+					detail, ok := subObj["detail"]
+					if ok {
+						subObj["detail"] = detail.(string)
+					} else {
+						subObj["detail"] = "auto"
+					}
+					contentList = append(contentList, MediaMessage{
+						Type: ContentTypeImageURL,
+						ImageUrl: MessageImageUrl{
+							Url:    subObj["url"].(string),
+							Detail: subObj["detail"].(string),
+						},
+					})
+				}
+			}
+		}
+		return contentList
+	}
+
+	return nil
+}
--- a/dto/text_response.go
+++ b/dto/text_response.go
@@ -0,0 +1,122 @@
+package dto
+
+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"`
+	FinishReason string `json:"finish_reason"`
+}
+
+type OpenAITextResponse struct {
+	Id      string                     `json:"id"`
+	Object  string                     `json:"object"`
+	Created int64                      `json:"created"`
+	Choices []OpenAITextResponseChoice `json:"choices"`
+	Usage   `json:"usage"`
+}
+
+type OpenAIEmbeddingResponseItem struct {
+	Object    string    `json:"object"`
+	Index     int       `json:"index"`
+	Embedding []float64 `json:"embedding"`
+}
+
+type OpenAIEmbeddingResponse struct {
+	Object string                        `json:"object"`
+	Data   []OpenAIEmbeddingResponseItem `json:"data"`
+	Model  string                        `json:"model"`
+	Usage  `json:"usage"`
+}
+
+type ChatCompletionsStreamResponseChoice struct {
+	Delta        ChatCompletionsStreamResponseChoiceDelta `json:"delta,omitempty"`
+	Logprobs     *any                                     `json:"logprobs"`
+	FinishReason *string                                  `json:"finish_reason"`
+	Index        int                                      `json:"index"`
+}
+
+type ChatCompletionsStreamResponseChoiceDelta struct {
+	Content   *string    `json:"content,omitempty"`
+	Role      string     `json:"role,omitempty"`
+	ToolCalls []ToolCall `json:"tool_calls,omitempty"`
+}
+
+func (c *ChatCompletionsStreamResponseChoiceDelta) IsEmpty() bool {
+	return c.Content == nil && len(c.ToolCalls) == 0
+}
+
+func (c *ChatCompletionsStreamResponseChoiceDelta) SetContentString(s string) {
+	c.Content = &s
+}
+
+func (c *ChatCompletionsStreamResponseChoiceDelta) GetContentString() string {
+	if c.Content == nil {
+		return ""
+	}
+	return *c.Content
+}
+
+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 {
+	Id                string                                `json:"id"`
+	Object            string                                `json:"object"`
+	Created           int64                                 `json:"created"`
+	Model             string                                `json:"model"`
+	SystemFingerprint *string                               `json:"system_fingerprint"`
+	Choices           []ChatCompletionsStreamResponseChoice `json:"choices"`
+}
+
+type ChatCompletionsStreamResponseSimple struct {
+	Choices []ChatCompletionsStreamResponseChoice `json:"choices"`
+}
+
+type CompletionsStreamResponse struct {
+	Choices []struct {
+		Text         string `json:"text"`
+		FinishReason string `json:"finish_reason"`
+	} `json:"choices"`
+}
+
+type Usage struct {
+	PromptTokens     int `json:"prompt_tokens"`
+	CompletionTokens int `json:"completion_tokens"`
+	TotalTokens      int `json:"total_tokens"`
+}
--- a/dto/video.go
+++ b/dto/video.go
@@ -1,47 +0,0 @@
-package dto
-
-type VideoRequest struct {
-	Model          string         `json:"model,omitempty" example:"kling-v1"`                                                                                                                                    // Model/style ID
-	Prompt         string         `json:"prompt,omitempty" example:"宇航员站起身走了"`                                                                                                                                   // Text prompt
-	Image          string         `json:"image,omitempty" example:"https://h2.inkwai.com/bs2/upload-ylab-stunt/se/ai_portal_queue_mmu_image_upscale_aiweb/3214b798-e1b4-4b00-b7af-72b5b0417420_raw_image_0.jpg"` // Image input (URL/Base64)
-	Duration       float64        `json:"duration" example:"5.0"`                                                                                                                                                // Video duration (seconds)
-	Width          int            `json:"width" example:"512"`                                                                                                                                                   // Video width
-	Height         int            `json:"height" example:"512"`                                                                                                                                                  // Video height
-	Fps            int            `json:"fps,omitempty" example:"30"`                                                                                                                                            // Video frame rate
-	Seed           int            `json:"seed,omitempty" example:"20231234"`                                                                                                                                     // Random seed
-	N              int            `json:"n,omitempty" example:"1"`                                                                                                                                               // Number of videos to generate
-	ResponseFormat string         `json:"response_format,omitempty" example:"url"`                                                                                                                               // Response format
-	User           string         `json:"user,omitempty" example:"user-1234"`                                                                                                                                    // User identifier
-	Metadata       map[string]any `json:"metadata,omitempty"`                                                                                                                                                    // Vendor-specific/custom params (e.g. negative_prompt, style, quality_level, etc.)
-}
-
-// VideoResponse 视频生成提交任务后的响应
-type VideoResponse struct {
-	TaskId string `json:"task_id"`
-	Status string `json:"status"`
-}
-
-// VideoTaskResponse 查询视频生成任务状态的响应
-type VideoTaskResponse struct {
-	TaskId   string             `json:"task_id" example:"abcd1234efgh"` // 任务ID
-	Status   string             `json:"status" example:"succeeded"`     // 任务状态
-	Url      string             `json:"url,omitempty"`                  // 视频资源URL（成功时）
-	Format   string             `json:"format,omitempty" example:"mp4"` // 视频格式
-	Metadata *VideoTaskMetadata `json:"metadata,omitempty"`             // 结果元数据
-	Error    *VideoTaskError    `json:"error,omitempty"`                // 错误信息（失败时）
-}
-
-// VideoTaskMetadata 视频任务元数据
-type VideoTaskMetadata struct {
-	Duration float64 `json:"duration" example:"5.0"`  // 实际生成的视频时长
-	Fps      int     `json:"fps" example:"30"`        // 实际帧率
-	Width    int     `json:"width" example:"512"`     // 实际宽度
-	Height   int     `json:"height" example:"512"`    // 实际高度
-	Seed     int     `json:"seed" example:"20231234"` // 使用的随机种子
-}
-
-// VideoTaskError 视频任务错误信息
-type VideoTaskError struct {
-	Code    int    `json:"code"`
-	Message string `json:"message"`
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Xyfacai	606aa8a4a7	feat: 调试 suno	2024-06-13 00:32:14 +08:00
Xiangyuan Liu	1e8abc7027	feat: suno api 支持	2024-06-12 20:37:42 +08:00