🐛 fix top-up link is null

merge

.air.toml

@@ -0,0 +1,46 @@
+root = "."
+testdata_dir = "testdata"
+tmp_dir = "tmp"
+
+[build]
+args_bin = []
+bin = "./tmp/main"
+cmd = "go build -o ./tmp/main ."
+delay = 1000
+exclude_dir = ["assets", "tmp", "vendor", "testdata", "web"]
+exclude_file = []
+exclude_regex = ["_test.go"]
+exclude_unchanged = false
+follow_symlink = false
+full_bin = ""
+include_dir = []
+include_ext = ["go", "tpl", "tmpl", "html"]
+include_file = []
+kill_delay = "0s"
+log = "build-errors.log"
+poll = false
+poll_interval = 0
+post_cmd = []
+pre_cmd = []
+rerun = false
+rerun_delay = 500
+send_interrupt = false
+stop_on_error = false
+
+[color]
+app = ""
+build = "yellow"
+main = "magenta"
+runner = "green"
+watcher = "cyan"
+
+[log]
+main_only = false
+time = false
+
+[misc]
+clean_on_exit = false
+
+[screen]
+clear_on_rebuild = false
+keep_scroll = true

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

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

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

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

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

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

.github/workflows/docker-image.yml

@@ -0,0 +1,62 @@
+name: one-api docker image
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - "v*"
+
+env:
+  # github.repository as <account>/<repo>
+  IMAGE_NAME: martialbe/one-api
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: read
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Login to GHCR
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GT_Token }}
+
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v4
+        with:
+          # list of Docker images to use as base name for tags
+          images: ghcr.io/${{ env.IMAGE_NAME }}
+          # generate Docker tags based on the following events/attributes
+          tags: |
+            type=raw,value=dev,enable=${{ github.ref == 'refs/heads/main' }}
+            type=raw,value=latest,enable=${{ startsWith(github.ref, 'refs/tags/') }}
+            type=pep440,pattern={{raw}},enable=${{ startsWith(github.ref, 'refs/tags/') }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          platforms: linux/amd64
+          build-args: |
+            COMMIT_SHA=${{ fromJSON(steps.meta.outputs.json).labels['org.opencontainers.image.revision'] }}
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

.github/workflows/linux-release.yml

@@ -5,8 +5,8 @@ permissions:
 on:
   push:
     tags:
-      - '*'
-      - '!*-alpha*'
+      - "*"
+      - "!*-alpha*"
 jobs:
   release:
     runs-on: ubuntu-latest
@@ -29,7 +29,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v3
         with:
-          go-version: '>=1.18.0'
+          go-version: ">=1.18.0"
       - name: Build Backend (amd64)
         run: |
           go mod download
@@ -51,4 +51,4 @@ jobs:
           draft: true
           generate_release_notes: true
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.GT_Token }}

.github/workflows/macos-release.yml

@@ -5,8 +5,8 @@ permissions:
 on:
   push:
     tags:
-      - '*'
-      - '!*-alpha*'
+      - "*"
+      - "!*-alpha*"
 jobs:
   release:
     runs-on: macos-latest
@@ -29,7 +29,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v3
         with:
-          go-version: '>=1.18.0'
+          go-version: ">=1.18.0"
       - name: Build Backend
         run: |
           go mod download
@@ -42,4 +42,4 @@ jobs:
           draft: true
           generate_release_notes: true
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.GT_Token }}

.github/workflows/windows-release.yml

@@ -5,8 +5,8 @@ permissions:
 on:
   push:
     tags:
-      - '*'
-      - '!*-alpha*'
+      - "*"
+      - "!*-alpha*"
 jobs:
   release:
     runs-on: windows-latest
@@ -32,7 +32,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v3
         with:
-          go-version: '>=1.18.0'
+          go-version: ">=1.18.0"
       - name: Build Backend
         run: |
           go mod download
@@ -45,4 +45,4 @@ jobs:
           draft: true
           generate_release_notes: true
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.GT_Token }}

.gitignore

@@ -6,4 +6,6 @@ upload
 build
 *.db-journal
 logs
-data
+data
+tmp/
+.env

README.en.md

@@ -10,28 +10,38 @@
 
 # One API
 
+_This project is a derivative of [one-api](https://github.com/songquanpeng/one-api), where the main focus has been on modularizing the module code from the original project and modifying the frontend interface. This project also adheres to the MIT License._
+
+<p align="center">
+  <a href="https://raw.githubusercontent.com/MartialBE/one-api/main/LICENSE">
+    <img src="https://img.shields.io/github/license/MartialBE/one-api?color=brightgreen" alt="license">
+  </a>
+  <a href="https://github.com/MartialBE/one-api/releases/latest">
+    <img src="https://img.shields.io/github/v/release/MartialBE/one-api?color=brightgreen&include_prereleases" alt="release">
+  </a>
+  <a href="https://github.com/users/MartialBE/packages/container/package/one-api">
+    <img src="https://img.shields.io/badge/docker-ghcr.io-blue" alt="docker">
+  </a>
+  <a href="https://goreportcard.com/report/github.com/MartialBE/one-api">
+    <img src="https://goreportcard.com/badge/github.com/MartialBE/one-api" alt="GoReportCard">
+  </a>
+</p>
+
+**Please do not mix with the original version, as the different channel ID may cause data disorder.**
+
+## Screenshots
+
+![dashboard](https://github.com/MartialBE/one-api/assets/42402987/c7f95d64-e7e3-4d0f-8ad8-36d6740da8db)
+![topup](https://github.com/MartialBE/one-api/assets/42402987/4bc9dbfd-84f6-4700-9ea5-308c09230c7a)
+
+_The following is the original project description:_
+
+---
+
 _✨ Access all LLM through the standard OpenAI API format, easy to deploy & use ✨_
 
 </div>
 
-<p align="center">
-  <a href="https://raw.githubusercontent.com/songquanpeng/one-api/main/LICENSE">
-    <img src="https://img.shields.io/github/license/songquanpeng/one-api?color=brightgreen" alt="license">
-  </a>
-  <a href="https://github.com/songquanpeng/one-api/releases/latest">
-    <img src="https://img.shields.io/github/v/release/songquanpeng/one-api?color=brightgreen&include_prereleases" alt="release">
-  </a>
-  <a href="https://hub.docker.com/repository/docker/justsong/one-api">
-    <img src="https://img.shields.io/docker/pulls/justsong/one-api?color=brightgreen" alt="docker pull">
-  </a>
-  <a href="https://github.com/songquanpeng/one-api/releases/latest">
-    <img src="https://img.shields.io/github/downloads/songquanpeng/one-api/total?color=brightgreen&include_prereleases" alt="release">
-  </a>
-  <a href="https://goreportcard.com/report/github.com/songquanpeng/one-api">
-    <img src="https://goreportcard.com/badge/github.com/songquanpeng/one-api" alt="GoReportCard">
-  </a>
-</p>
-
 <p align="center">
   <a href="#deployment">Deployment Tutorial</a>
   ·
@@ -57,13 +67,14 @@ _✨ Access all LLM through the standard OpenAI API format, easy to deploy & use
 > **Note**: The latest image pulled from Docker may be an `alpha` release. Specify the version manually if you require stability.
 
 ## Features
+
 1. Support for multiple large models:
-   + [x] [OpenAI ChatGPT Series Models](https://platform.openai.com/docs/guides/gpt/chat-completions-api) (Supports [Azure OpenAI API](https://learn.microsoft.com/en-us/azure/ai-services/openai/reference))
-   + [x] [Anthropic Claude Series Models](https://anthropic.com)
-   + [x] [Google PaLM2 and Gemini Series Models](https://developers.generativeai.google)
-   + [x] [Baidu Wenxin Yiyuan Series Models](https://cloud.baidu.com/doc/WENXINWORKSHOP/index.html)
-   + [x] [Alibaba Tongyi Qianwen Series Models](https://help.aliyun.com/document_detail/2400395.html)
-   + [x] [Zhipu ChatGLM Series Models](https://bigmodel.cn)
+   - [x] [OpenAI ChatGPT Series Models](https://platform.openai.com/docs/guides/gpt/chat-completions-api) (Supports [Azure OpenAI API](https://learn.microsoft.com/en-us/azure/ai-services/openai/reference))
+   - [x] [Anthropic Claude Series Models](https://anthropic.com)
+   - [x] [Google PaLM2 and Gemini Series Models](https://developers.generativeai.google)
+   - [x] [Baidu Wenxin Yiyuan Series Models](https://cloud.baidu.com/doc/WENXINWORKSHOP/index.html)
+   - [x] [Alibaba Tongyi Qianwen Series Models](https://help.aliyun.com/document_detail/2400395.html)
+   - [x] [Zhipu ChatGLM Series Models](https://bigmodel.cn)
 2. Supports access to multiple channels through **load balancing**.
 3. Supports **stream mode** that enables typewriter-like effect through stream transmission.
 4. Supports **multi-machine deployment**. [See here](#multi-machine-deployment) for more details.
@@ -82,13 +93,15 @@ _✨ Access all LLM through the standard OpenAI API format, easy to deploy & use
 15. Supports management API access through system access tokens.
 16. Supports Cloudflare Turnstile user verification.
 17. Supports user management and multiple user login/registration methods:
-    + Email login/registration and password reset via email.
-    + [GitHub OAuth](https://github.com/settings/applications/new).
-    + WeChat Official Account authorization (requires additional deployment of [WeChat Server](https://github.com/songquanpeng/wechat-server)).
+    - Email login/registration and password reset via email.
+    - [GitHub OAuth](https://github.com/settings/applications/new).
+    - WeChat Official Account authorization (requires additional deployment of [WeChat Server](https://github.com/songquanpeng/wechat-server)).
 18. Immediate support and encapsulation of other major model APIs as they become available.
 
 ## Deployment
+
 ### Docker Deployment
+
 Deployment command: `docker run --name one-api -d --restart always -p 3000:3000 -e TZ=Asia/Shanghai -v /home/ubuntu/data/one-api:/data justsong/one-api-en`
 
 Update command: `docker run --rm -v /var/run/docker.sock:/var/run/docker.sock containrrr/watchtower -cR`
@@ -98,10 +111,11 @@ The first `3000` in `-p 3000:3000` is the port of the host, which can be modifie
 Data will be saved in the `/home/ubuntu/data/one-api` directory on the host. Ensure that the directory exists and has write permissions, or change it to a suitable directory.
 
 Nginx reference configuration:
+
 ```
 server{
    server_name openai.justsong.cn;  # Modify your domain name accordingly
-   
+
    location / {
           client_max_body_size  64m;
           proxy_http_version 1.1;
@@ -115,6 +129,7 @@ server{
 ```
 
 Next, configure HTTPS with Let's Encrypt certbot:
+
 ```bash
 # Install certbot on Ubuntu:
 sudo snap install --classic certbot
@@ -129,20 +144,23 @@ sudo service nginx restart
 The initial account username is `root` and password is `123456`.
 
 ### Manual Deployment
+
 1. Download the executable file from [GitHub Releases](https://github.com/songquanpeng/one-api/releases/latest) or compile from source:
+
    ```shell
    git clone https://github.com/songquanpeng/one-api.git
-   
+
    # Build the frontend
    cd one-api/web
    npm install
    npm run build
-   
+
    # Build the backend
    cd ..
    go mod download
    go build -ldflags "-s -w" -o one-api
    ```
+
 2. Run:
    ```shell
    chmod u+x one-api
@@ -153,6 +171,7 @@ The initial account username is `root` and password is `123456`.
 For more detailed deployment tutorials, please refer to [this page](https://iamazing.cn/page/how-to-deploy-a-website).
 
 ### Multi-machine Deployment
+
 1. Set the same `SESSION_SECRET` for all servers.
 2. Set `SQL_DSN` and use MySQL instead of SQLite. All servers should connect to the same database.
 3. Set the `NODE_TYPE` for all non-master nodes to `slave`.
@@ -164,11 +183,13 @@ For more detailed deployment tutorials, please refer to [this page](https://iama
 Please refer to the [environment variables](#environment-variables) section for details on using environment variables.
 
 ### Deployment on Control Panels (e.g., Baota)
+
 Refer to [#175](https://github.com/songquanpeng/one-api/issues/175) for detailed instructions.
 
 If you encounter a blank page after deployment, refer to [#97](https://github.com/songquanpeng/one-api/issues/97) for possible solutions.
 
 ### Deployment on Third-Party Platforms
+
 <details>
 <summary><strong>Deploy on Sealos</strong></summary>
 <div>
@@ -179,7 +200,6 @@ If you encounter a blank page after deployment, refer to [#97](https://github.co
 
 [![](https://raw.githubusercontent.com/labring-actions/templates/main/Deploy-on-Sealos.svg)](https://cloud.sealos.io/?openapp=system-fastdeploy?templateName=one-api)
 
-
 </div>
 </details>
 
@@ -194,7 +214,7 @@ If you encounter a blank page after deployment, refer to [#97](https://github.co
 1. First, fork the code.
 2. Go to [Zeabur](https://zeabur.com?referralCode=songquanpeng), log in, and enter the console.
 3. Create a new project. In Service -> Add Service, select Marketplace, and choose MySQL. Note down the connection parameters (username, password, address, and port).
-4. Copy the connection parameters and run ```create database `one-api` ``` to create the database.
+4. Copy the connection parameters and run `` create database `one-api`  `` to create the database.
 5. Then, in Service -> Add Service, select Git (authorization is required for the first use) and choose your forked repository.
 6. Automatic deployment will start, but please cancel it for now. Go to the Variable tab, add a `PORT` with a value of `3000`, and then add a `SQL_DSN` with a value of `<username>:<password>@tcp(<addr>:<port>)/one-api`. Save the changes. Please note that if `SQL_DSN` is not set, data will not be persisted, and the data will be lost after redeployment.
 7. Select Redeploy.
@@ -205,6 +225,7 @@ If you encounter a blank page after deployment, refer to [#97](https://github.co
 </details>
 
 ## Configuration
+
 The system is ready to use out of the box.
 
 You can configure it by setting environment variables or command line parameters.
@@ -212,6 +233,7 @@ You can configure it by setting environment variables or command line parameters
 After the system starts, log in as the `root` user to further configure the system.
 
 ## Usage
+
 Add your API Key on the `Channels` page, and then add an access token on the `Tokens` page.
 
 You can then use your access token to access One API. The usage is consistent with the [OpenAI API](https://platform.openai.com/docs/api-reference/introduction).
@@ -235,59 +257,65 @@ Note that the token needs to be created by an administrator to specify the chann
 If the channel ID is not provided, load balancing will be used to distribute the requests to multiple channels.
 
 ### Environment Variables
+
 1. `REDIS_CONN_STRING`: When set, Redis will be used as the storage for request rate limiting instead of memory.
-    + Example: `REDIS_CONN_STRING=redis://default:redispw@localhost:49153`
+   - Example: `REDIS_CONN_STRING=redis://default:redispw@localhost:49153`
 2. `SESSION_SECRET`: When set, a fixed session key will be used to ensure that cookies of logged-in users are still valid after the system restarts.
-    + Example: `SESSION_SECRET=random_string`
+   - Example: `SESSION_SECRET=random_string`
 3. `SQL_DSN`: When set, the specified database will be used instead of SQLite. Please use MySQL version 8.0.
-    + Example: `SQL_DSN=root:123456@tcp(localhost:3306)/oneapi`
+   - Example: `SQL_DSN=root:123456@tcp(localhost:3306)/oneapi`
 4. `FRONTEND_BASE_URL`: When set, the specified frontend address will be used instead of the backend address.
-    + Example: `FRONTEND_BASE_URL=https://openai.justsong.cn`
+   - Example: `FRONTEND_BASE_URL=https://openai.justsong.cn`
 5. `SYNC_FREQUENCY`: When set, the system will periodically sync configurations from the database, with the unit in seconds. If not set, no sync will happen.
-    + Example: `SYNC_FREQUENCY=60`
+   - Example: `SYNC_FREQUENCY=60`
 6. `NODE_TYPE`: When set, specifies the node type. Valid values are `master` and `slave`. If not set, it defaults to `master`.
-    + Example: `NODE_TYPE=slave`
+   - Example: `NODE_TYPE=slave`
 7. `CHANNEL_UPDATE_FREQUENCY`: When set, it periodically updates the channel balances, with the unit in minutes. If not set, no update will happen.
-    + Example: `CHANNEL_UPDATE_FREQUENCY=1440`
+   - Example: `CHANNEL_UPDATE_FREQUENCY=1440`
 8. `CHANNEL_TEST_FREQUENCY`: When set, it periodically tests the channels, with the unit in minutes. If not set, no test will happen.
-    + Example: `CHANNEL_TEST_FREQUENCY=1440`
+   - Example: `CHANNEL_TEST_FREQUENCY=1440`
 9. `POLLING_INTERVAL`: The time interval (in seconds) between requests when updating channel balances and testing channel availability. Default is no interval.
-    + Example: `POLLING_INTERVAL=5`
+   - Example: `POLLING_INTERVAL=5`
 
 ### Command Line Parameters
+
 1. `--port <port_number>`: Specifies the port number on which the server listens. Defaults to `3000`.
-    + Example: `--port 3000`
+   - Example: `--port 3000`
 2. `--log-dir <log_dir>`: Specifies the log directory. If not set, the logs will not be saved.
-    + Example: `--log-dir ./logs`
+   - Example: `--log-dir ./logs`
 3. `--version`: Prints the system version number and exits.
 4. `--help`: Displays the command usage help and parameter descriptions.
 
 ## Screenshots
+
 ![channel](https://user-images.githubusercontent.com/39998050/233837954-ae6683aa-5c4f-429f-a949-6645a83c9490.png)
 ![token](https://user-images.githubusercontent.com/39998050/233837971-dab488b7-6d96-43af-b640-a168e8d1c9bf.png)
 
 ## FAQ
+
 1. What is quota? How is it calculated? Does One API have quota calculation issues?
-    + Quota = Group multiplier * Model multiplier * (number of prompt tokens + number of completion tokens * completion multiplier)
-    + The completion multiplier is fixed at 1.33 for GPT3.5 and 2 for GPT4, consistent with the official definition.
-    + If it is not a stream mode, the official API will return the total number of tokens consumed. However, please note that the consumption multipliers for prompts and completions are different.
+   - Quota = Group multiplier _ Model multiplier _ (number of prompt tokens + number of completion tokens \* completion multiplier)
+   - The completion multiplier is fixed at 1.33 for GPT3.5 and 2 for GPT4, consistent with the official definition.
+   - If it is not a stream mode, the official API will return the total number of tokens consumed. However, please note that the consumption multipliers for prompts and completions are different.
 2. Why does it prompt "insufficient quota" even though my account balance is sufficient?
-    + Please check if your token quota is sufficient. It is separate from the account balance.
-    + The token quota is used to set the maximum usage and can be freely set by the user.
+   - Please check if your token quota is sufficient. It is separate from the account balance.
+   - The token quota is used to set the maximum usage and can be freely set by the user.
 3. It says "No available channels" when trying to use a channel. What should I do?
-    + Please check the user and channel group settings.
-    + Also check the channel model settings.
+   - Please check the user and channel group settings.
+   - Also check the channel model settings.
 4. Channel testing reports an error: "invalid character '<' looking for beginning of value"
-    + This error occurs when the returned value is not valid JSON but an HTML page.
-    + Most likely, the IP of your deployment site or the node of the proxy has been blocked by CloudFlare.
+   - This error occurs when the returned value is not valid JSON but an HTML page.
+   - Most likely, the IP of your deployment site or the node of the proxy has been blocked by CloudFlare.
 5. ChatGPT Next Web reports an error: "Failed to fetch"
-    + Do not set `BASE_URL` during deployment.
-    + Double-check that your interface address and API Key are correct.
+   - Do not set `BASE_URL` during deployment.
+   - Double-check that your interface address and API Key are correct.
 
 ## Related Projects
+
 [FastGPT](https://github.com/labring/FastGPT): Knowledge question answering system based on the LLM
 
 ## Note
+
 This project is an open-source project. Please use it in compliance with OpenAI's [Terms of Use](https://openai.com/policies/terms-of-use) and **applicable laws and regulations**. It must not be used for illegal purposes.
 
 This project is released under the MIT license. Based on this, attribution and a link to this project must be included at the bottom of the page.

README.ja.md

@@ -10,28 +10,38 @@
 
 # One API
 
+_このプロジェクトは、[one-api](https://github.com/songquanpeng/one-api)をベースにしており、元のプロジェクトのモジュールコードを分離し、モジュール化し、フロントエンドのインターフェースを変更しました。このプロジェクトも MIT ライセンスに従っています。_
+
+<p align="center">
+  <a href="https://raw.githubusercontent.com/MartialBE/one-api/main/LICENSE">
+    <img src="https://img.shields.io/github/license/MartialBE/one-api?color=brightgreen" alt="license">
+  </a>
+  <a href="https://github.com/MartialBE/one-api/releases/latest">
+    <img src="https://img.shields.io/github/v/release/MartialBE/one-api?color=brightgreen&include_prereleases" alt="release">
+  </a>
+  <a href="https://github.com/users/MartialBE/packages/container/package/one-api">
+    <img src="https://img.shields.io/badge/docker-ghcr.io-blue" alt="docker">
+  </a>
+  <a href="https://goreportcard.com/report/github.com/MartialBE/one-api">
+    <img src="https://goreportcard.com/badge/github.com/MartialBE/one-api" alt="GoReportCard">
+  </a>
+</p>
+
+**オリジナルバージョンと混合しないでください。チャンネル ID が異なるため、データの混乱を引き起こす可能性があります**
+
+## スクリーンショット
+
+![dashboard](https://github.com/MartialBE/one-api/assets/42402987/c7f95d64-e7e3-4d0f-8ad8-36d6740da8db)
+![topup](https://github.com/MartialBE/one-api/assets/42402987/4bc9dbfd-84f6-4700-9ea5-308c09230c7a)
+
+_以下は元の項目の説明です：_
+
+---
+
 _✨ 標準的な OpenAI API フォーマットを通じてすべての LLM にアクセスでき、導入と利用が容易です ✨_
 
 </div>
 
-<p align="center">
-  <a href="https://raw.githubusercontent.com/songquanpeng/one-api/main/LICENSE">
-    <img src="https://img.shields.io/github/license/songquanpeng/one-api?color=brightgreen" alt="license">
-  </a>
-  <a href="https://github.com/songquanpeng/one-api/releases/latest">
-    <img src="https://img.shields.io/github/v/release/songquanpeng/one-api?color=brightgreen&include_prereleases" alt="release">
-  </a>
-  <a href="https://hub.docker.com/repository/docker/justsong/one-api">
-    <img src="https://img.shields.io/docker/pulls/justsong/one-api?color=brightgreen" alt="docker pull">
-  </a>
-  <a href="https://github.com/songquanpeng/one-api/releases/latest">
-    <img src="https://img.shields.io/github/downloads/songquanpeng/one-api/total?color=brightgreen&include_prereleases" alt="release">
-  </a>
-  <a href="https://goreportcard.com/report/github.com/songquanpeng/one-api">
-    <img src="https://goreportcard.com/badge/github.com/songquanpeng/one-api" alt="GoReportCard">
-  </a>
-</p>
-
 <p align="center">
   <a href="#deployment">デプロイチュートリアル</a>
   ·
@@ -57,13 +67,14 @@ _✨ 標準的な OpenAI API フォーマットを通じてすべての LLM に
 > **注**: Docker からプルされた最新のイメージは、`alpha` リリースかもしれません。安定性が必要な場合は、手動でバージョンを指定してください。
 
 ## 特徴
+
 1. 複数の大型モデルをサポート:
-   + [x] [OpenAI ChatGPT シリーズモデル](https://platform.openai.com/docs/guides/gpt/chat-completions-api) ([Azure OpenAI API](https://learn.microsoft.com/en-us/azure/ai-services/openai/reference) をサポート)
-   + [x] [Anthropic Claude シリーズモデル](https://anthropic.com)
-   + [x] [Google PaLM2/Gemini シリーズモデル](https://developers.generativeai.google)
-   + [x] [Baidu Wenxin Yiyuan シリーズモデル](https://cloud.baidu.com/doc/WENXINWORKSHOP/index.html)
-   + [x] [Alibaba Tongyi Qianwen シリーズモデル](https://help.aliyun.com/document_detail/2400395.html)
-   + [x] [Zhipu ChatGLM シリーズモデル](https://bigmodel.cn)
+   - [x] [OpenAI ChatGPT シリーズモデル](https://platform.openai.com/docs/guides/gpt/chat-completions-api) ([Azure OpenAI API](https://learn.microsoft.com/en-us/azure/ai-services/openai/reference) をサポート)
+   - [x] [Anthropic Claude シリーズモデル](https://anthropic.com)
+   - [x] [Google PaLM2/Gemini シリーズモデル](https://developers.generativeai.google)
+   - [x] [Baidu Wenxin Yiyuan シリーズモデル](https://cloud.baidu.com/doc/WENXINWORKSHOP/index.html)
+   - [x] [Alibaba Tongyi Qianwen シリーズモデル](https://help.aliyun.com/document_detail/2400395.html)
+   - [x] [Zhipu ChatGLM シリーズモデル](https://bigmodel.cn)
 2. **ロードバランシング**による複数チャンネルへのアクセスをサポート。
 3. ストリーム伝送によるタイプライター的効果を可能にする**ストリームモード**に対応。
 4. **マルチマシンデプロイ**に対応。[詳細はこちら](#multi-machine-deployment)を参照。
@@ -82,13 +93,15 @@ _✨ 標準的な OpenAI API フォーマットを通じてすべての LLM に
 15. システム・アクセストークンによる管理 API アクセスをサポートする。
 16. Cloudflare Turnstile によるユーザー認証に対応。
 17. ユーザー管理と複数のユーザーログイン/登録方法をサポート:
-    + 電子メールによるログイン/登録とパスワードリセット。
-    + [GitHub OAuth](https://github.com/settings/applications/new)。
-    + WeChat 公式アカウントの認証（[WeChat Server](https://github.com/songquanpeng/wechat-server)の追加導入が必要）。
+    - 電子メールによるログイン/登録とパスワードリセット。
+    - [GitHub OAuth](https://github.com/settings/applications/new)。
+    - WeChat 公式アカウントの認証（[WeChat Server](https://github.com/songquanpeng/wechat-server)の追加導入が必要）。
 18. 他の主要なモデル API が利用可能になった場合、即座にサポートし、カプセル化する。
 
 ## デプロイメント
+
 ### Docker デプロイメント
+
 デプロイコマンド: `docker run --name one-api -d --restart always -p 3000:3000 -e TZ=Asia/Shanghai -v /home/ubuntu/data/one-api:/data justsong/one-api-en`。
 
 コマンドを更新する: `docker run --rm -v /var/run/docker.sock:/var/run/docker.sock containrr/watchtower -cR`。
@@ -97,7 +110,8 @@ _✨ 標準的な OpenAI API フォーマットを通じてすべての LLM に
 
 データはホストの `/home/ubuntu/data/one-api` ディレクトリに保存される。このディレクトリが存在し、書き込み権限があることを確認する、もしくは適切なディレクトリに変更してください。
 
-Nginxリファレンス設定:
+Nginx リファレンス設定:
+
 ```
 server{
    server_name openai.justsong.cn;  # ドメイン名は適宜変更
@@ -116,6 +130,7 @@ server{
 ```
 
 次に、Let's Encrypt certbot を使って HTTPS を設定します:
+
 ```bash
 # Ubuntu に certbot をインストール:
 sudo snap install --classic certbot
@@ -130,7 +145,9 @@ sudo service nginx restart
 初期アカウントのユーザー名は `root` で、パスワードは `123456` です。
 
 ### マニュアルデプロイ
+
 1. [GitHub Releases](https://github.com/songquanpeng/one-api/releases/latest) から実行ファイルをダウンロードする、もしくはソースからコンパイルする:
+
    ```shell
    git clone https://github.com/songquanpeng/one-api.git
 
@@ -144,6 +161,7 @@ sudo service nginx restart
    go mod download
    go build -ldflags "-s -w" -o one-api
    ```
+
 2. 実行:
    ```shell
    chmod u+x one-api
@@ -154,6 +172,7 @@ sudo service nginx restart
 より詳細なデプロイのチュートリアルについては、[このページ](https://iamazing.cn/page/how-to-deploy-a-website) を参照してください。
 
 ### マルチマシンデプロイ
+
 1. すべてのサーバに同じ `SESSION_SECRET` を設定する。
 2. `SQL_DSN` を設定し、SQLite の代わりに MySQL を使用する。すべてのサーバは同じデータベースに接続する。
 3. マスターノード以外のノードの `NODE_TYPE` を `slave` に設定する。
@@ -165,11 +184,13 @@ sudo service nginx restart
 Please refer to the [environment variables](#environment-variables) section for details on using environment variables.
 
 ### コントロールパネル（例: Baota）への展開
+
 詳しい手順は [#175](https://github.com/songquanpeng/one-api/issues/175) を参照してください。
 
 配置後に空白のページが表示される場合は、[#97](https://github.com/songquanpeng/one-api/issues/97) を参照してください。
 
 ### サードパーティプラットフォームへのデプロイ
+
 <details>
 <summary><strong>Sealos へのデプロイ</strong></summary>
 <div>
@@ -180,7 +201,6 @@ Please refer to the [environment variables](#environment-variables) section for
 
 [![](https://raw.githubusercontent.com/labring-actions/templates/main/Deploy-on-Sealos.svg)](https://cloud.sealos.io/?openapp=system-fastdeploy?templateName=one-api)
 
-
 </div>
 </details>
 
@@ -194,8 +214,8 @@ Please refer to the [environment variables](#environment-variables) section for
 
 1. まず、コードをフォークする。
 2. [Zeabur](https://zeabur.com?referralCode=songquanpeng) にアクセスしてログインし、コンソールに入る。
-3. 新しいプロジェクトを作成します。Service -> Add ServiceでMarketplace を選択し、MySQL を選択する。接続パラメータ（ユーザー名、パスワード、アドレス、ポート）をメモします。
-4. 接続パラメータをコピーし、```create database `one-api` ``` を実行してデータベースを作成する。
+3. 新しいプロジェクトを作成します。Service -> Add Service で Marketplace を選択し、MySQL を選択する。接続パラメータ（ユーザー名、パスワード、アドレス、ポート）をメモします。
+4. 接続パラメータをコピーし、`` create database `one-api`  `` を実行してデータベースを作成する。
 5. その後、Service -> Add Service で Git を選択し（最初の使用には認証が必要です）、フォークしたリポジトリを選択します。
 6. 自動デプロイが開始されますが、一旦キャンセルしてください。Variable タブで `PORT` に `3000` を追加し、`SQL_DSN` に `<username>:<password>@tcp(<addr>:<port>)/one-api` を追加します。変更を保存する。SQL_DSN` が設定されていないと、データが永続化されず、再デプロイ後にデータが失われるので注意すること。
 7. 再デプロイを選択します。
@@ -206,6 +226,7 @@ Please refer to the [environment variables](#environment-variables) section for
 </details>
 
 ## コンフィグ
+
 システムは箱から出してすぐに使えます。
 
 環境変数やコマンドラインパラメータを設定することで、システムを構成することができます。
@@ -213,6 +234,7 @@ Please refer to the [environment variables](#environment-variables) section for
 システム起動後、`root` ユーザーとしてログインし、さらにシステムを設定します。
 
 ## 使用方法
+
 `Channels` ページで API Key を追加し、`Tokens` ページでアクセストークンを追加する。
 
 アクセストークンを使って One API にアクセスすることができる。使い方は [OpenAI API](https://platform.openai.com/docs/api-reference/introduction) と同じです。
@@ -236,59 +258,65 @@ graph LR
 もしチャネル ID が指定されない場合、ロードバランシングによってリクエストが複数のチャネルに振り分けられます。
 
 ### 環境変数
+
 1. `REDIS_CONN_STRING`: 設定すると、リクエストレート制限のためのストレージとして、メモリの代わりに Redis が使われる。
-    + 例: `REDIS_CONN_STRING=redis://default:redispw@localhost:49153`
+   - 例: `REDIS_CONN_STRING=redis://default:redispw@localhost:49153`
 2. `SESSION_SECRET`: 設定すると、固定セッションキーが使用され、システムの再起動後もログインユーザーのクッキーが有効であることが保証されます。
-    + 例: `SESSION_SECRET=random_string`
+   - 例: `SESSION_SECRET=random_string`
 3. `SQL_DSN`: 設定すると、SQLite の代わりに指定したデータベースが使用されます。MySQL バージョン 8.0 を使用してください。
-    + 例: `SQL_DSN=root:123456@tcp(localhost:3306)/oneapi`
+   - 例: `SQL_DSN=root:123456@tcp(localhost:3306)/oneapi`
 4. `FRONTEND_BASE_URL`: 設定されると、バックエンドアドレスではなく、指定されたフロントエンドアドレスが使われる。
-    + 例: `FRONTEND_BASE_URL=https://openai.justsong.cn`
+   - 例: `FRONTEND_BASE_URL=https://openai.justsong.cn`
 5. `SYNC_FREQUENCY`: 設定された場合、システムは定期的にデータベースからコンフィグを秒単位で同期する。設定されていない場合、同期は行われません。
-    + 例: `SYNC_FREQUENCY=60`
+   - 例: `SYNC_FREQUENCY=60`
 6. `NODE_TYPE`: 設定すると、ノードのタイプを指定する。有効な値は `master` と `slave` である。設定されていない場合、デフォルトは `master`。
-    + 例: `NODE_TYPE=slave`
+   - 例: `NODE_TYPE=slave`
 7. `CHANNEL_UPDATE_FREQUENCY`: 設定すると、チャンネル残高を分単位で定期的に更新する。設定されていない場合、更新は行われません。
-    + 例: `CHANNEL_UPDATE_FREQUENCY=1440`
+   - 例: `CHANNEL_UPDATE_FREQUENCY=1440`
 8. `CHANNEL_TEST_FREQUENCY`: 設定すると、チャンネルを定期的にテストする。設定されていない場合、テストは行われません。
-    + 例: `CHANNEL_TEST_FREQUENCY=1440`
+   - 例: `CHANNEL_TEST_FREQUENCY=1440`
 9. `POLLING_INTERVAL`: チャネル残高の更新とチャネルの可用性をテストするときのリクエスト間の時間間隔 (秒)。デフォルトは間隔なし。
-    + 例: `POLLING_INTERVAL=5`
+   - 例: `POLLING_INTERVAL=5`
 
 ### コマンドラインパラメータ
+
 1. `--port <port_number>`: サーバがリッスンするポート番号を指定。デフォルトは `3000` です。
-    + 例: `--port 3000`
+   - 例: `--port 3000`
 2. `--log-dir <log_dir>`: ログディレクトリを指定。設定しない場合、ログは保存されません。
-    + 例: `--log-dir ./logs`
+   - 例: `--log-dir ./logs`
 3. `--version`: システムのバージョン番号を表示して終了する。
 4. `--help`: コマンドの使用法ヘルプとパラメータの説明を表示。
 
 ## スクリーンショット
+
 ![channel](https://user-images.githubusercontent.com/39998050/233837954-ae6683aa-5c4f-429f-a949-6645a83c9490.png)
 ![token](https://user-images.githubusercontent.com/39998050/233837971-dab488b7-6d96-43af-b640-a168e8d1c9bf.png)
 
 ## FAQ
+
 1. ノルマとは何か？どのように計算されますか？One API にはノルマ計算の問題はありますか？
-    + ノルマ = グループ倍率 * モデル倍率 * (プロンプトトークンの数 + 完了トークンの数 * 完了倍率)
-    + 完了倍率は、公式の定義と一致するように、GPT3.5 では 1.33、GPT4 では 2 に固定されています。
-    + ストリームモードでない場合、公式 API は消費したトークンの総数を返す。ただし、プロンプトとコンプリートの消費倍率は異なるので注意してください。
+   - ノルマ = グループ倍率 _ モデル倍率 _ (プロンプトトークンの数 + 完了トークンの数 \* 完了倍率)
+   - 完了倍率は、公式の定義と一致するように、GPT3.5 では 1.33、GPT4 では 2 に固定されています。
+   - ストリームモードでない場合、公式 API は消費したトークンの総数を返す。ただし、プロンプトとコンプリートの消費倍率は異なるので注意してください。
 2. アカウント残高は十分なのに、"insufficient quota" と表示されるのはなぜですか？
-    + トークンのクォータが十分かどうかご確認ください。トークンクォータはアカウント残高とは別のものです。
-    + トークンクォータは最大使用量を設定するためのもので、ユーザーが自由に設定できます。
+   - トークンのクォータが十分かどうかご確認ください。トークンクォータはアカウント残高とは別のものです。
+   - トークンクォータは最大使用量を設定するためのもので、ユーザーが自由に設定できます。
 3. チャンネルを使おうとすると "No available channels" と表示されます。どうすればいいですか？
-    + ユーザーとチャンネルグループの設定を確認してください。
-    + チャンネルモデルの設定も確認してください。
+   - ユーザーとチャンネルグループの設定を確認してください。
+   - チャンネルモデルの設定も確認してください。
 4. チャンネルテストがエラーを報告する: "invalid character '<' looking for beginning of value"
-    + このエラーは、返された値が有効な JSON ではなく、HTML ページである場合に発生する。
-    + ほとんどの場合、デプロイサイトのIPかプロキシのノードが CloudFlare によってブロックされています。
+   - このエラーは、返された値が有効な JSON ではなく、HTML ページである場合に発生する。
+   - ほとんどの場合、デプロイサイトの IP かプロキシのノードが CloudFlare によってブロックされています。
 5. ChatGPT Next Web でエラーが発生しました: "Failed to fetch"
-    + デプロイ時に `BASE_URL` を設定しないでください。
-    + インターフェイスアドレスと API Key が正しいか再確認してください。
+   - デプロイ時に `BASE_URL` を設定しないでください。
+   - インターフェイスアドレスと API Key が正しいか再確認してください。
 
 ## 関連プロジェクト
+
 [FastGPT](https://github.com/labring/FastGPT): LLM に基づく知識質問応答システム
 
 ## 注
+
 本プロジェクトはオープンソースプロジェクトです。OpenAI の[利用規約](https://openai.com/policies/terms-of-use)および**適用される法令**を遵守してご利用ください。違法な目的での利用はご遠慮ください。
 
 このプロジェクトは MIT ライセンスで公開されています。これに基づき、ページの最下部に帰属表示と本プロジェクトへのリンクを含める必要があります。

README.md

@@ -2,37 +2,46 @@
    <strong>中文</strong> | <a href="./README.en.md">English</a> | <a href="./README.ja.md">日本語</a>
 </p>
 
-
 <p align="center">
-  <a href="https://github.com/songquanpeng/one-api"><img src="https://raw.githubusercontent.com/songquanpeng/one-api/main/web/public/logo.png" width="150" height="150" alt="one-api logo"></a>
+  <a href="https://github.com/MartialBE/one-api"><img src="https://raw.githubusercontent.com/MartialBE/one-api/main/web/src/assets/images/logo.svg" width="150" height="150" alt="one-api logo"></a>
 </p>
 
 <div align="center">
 
 # One API
 
+_本项目是基于[one-api](https://github.com/songquanpeng/one-api)二次开发而来的，主要将原项目中的模块代码分离，模块化，并修改了前端界面。本项目同样遵循 MIT 协议。_
+
+<p align="center">
+  <a href="https://raw.githubusercontent.com/MartialBE/one-api/main/LICENSE">
+    <img src="https://img.shields.io/github/license/MartialBE/one-api?color=brightgreen" alt="license">
+  </a>
+  <a href="https://github.com/MartialBE/one-api/releases/latest">
+    <img src="https://img.shields.io/github/v/release/MartialBE/one-api?color=brightgreen&include_prereleases" alt="release">
+  </a>
+  <a href="https://github.com/users/MartialBE/packages/container/package/one-api">
+    <img src="https://img.shields.io/badge/docker-ghcr.io-blue" alt="docker">
+  </a>
+  <a href="https://goreportcard.com/report/github.com/MartialBE/one-api">
+    <img src="https://goreportcard.com/badge/github.com/MartialBE/one-api" alt="GoReportCard">
+  </a>
+</p>
+
+**请不要和原版混用，因为 channel id 不同的原因，会导致数据错乱**
+
+# 截图展示
+
+![dashboard](https://github.com/MartialBE/one-api/assets/42402987/c7f95d64-e7e3-4d0f-8ad8-36d6740da8db)
+![topup](https://github.com/MartialBE/one-api/assets/42402987/4bc9dbfd-84f6-4700-9ea5-308c09230c7a)
+
+_以下为原项目说明：_
+
+---
+
 _✨ 通过标准的 OpenAI API 格式访问所有的大模型，开箱即用 ✨_
 
 </div>
 
-<p align="center">
-  <a href="https://raw.githubusercontent.com/songquanpeng/one-api/main/LICENSE">
-    <img src="https://img.shields.io/github/license/songquanpeng/one-api?color=brightgreen" alt="license">
-  </a>
-  <a href="https://github.com/songquanpeng/one-api/releases/latest">
-    <img src="https://img.shields.io/github/v/release/songquanpeng/one-api?color=brightgreen&include_prereleases" alt="release">
-  </a>
-  <a href="https://hub.docker.com/repository/docker/justsong/one-api">
-    <img src="https://img.shields.io/docker/pulls/justsong/one-api?color=brightgreen" alt="docker pull">
-  </a>
-  <a href="https://github.com/songquanpeng/one-api/releases/latest">
-    <img src="https://img.shields.io/github/downloads/songquanpeng/one-api/total?color=brightgreen&include_prereleases" alt="release">
-  </a>
-  <a href="https://goreportcard.com/report/github.com/songquanpeng/one-api">
-    <img src="https://goreportcard.com/badge/github.com/songquanpeng/one-api" alt="GoReportCard">
-  </a>
-</p>
-
 <p align="center">
   <a href="https://github.com/songquanpeng/one-api#部署">部署教程</a>
   ·
@@ -53,7 +62,7 @@ _✨ 通过标准的 OpenAI API 格式访问所有的大模型，开箱即用
 
 > [!NOTE]
 > 本项目为开源项目，使用者必须在遵循 OpenAI 的[使用条款](https://openai.com/policies/terms-of-use)以及**法律法规**的情况下使用，不得用于非法用途。
-> 
+>
 > 根据[《生成式人工智能服务管理暂行办法》](http://www.cac.gov.cn/2023-07/13/c_1690898327029107.htm)的要求，请勿对中国地区公众提供一切未经备案的生成式人工智能服务。
 
 > [!WARNING]
@@ -63,16 +72,17 @@ _✨ 通过标准的 OpenAI API 格式访问所有的大模型，开箱即用
 > 使用 root 用户初次登录系统后，务必修改默认密码 `123456`！
 
 ## 功能
+
 1. 支持多种大模型：
-   + [x] [OpenAI ChatGPT 系列模型](https://platform.openai.com/docs/guides/gpt/chat-completions-api)（支持 [Azure OpenAI API](https://learn.microsoft.com/en-us/azure/ai-services/openai/reference)）
-   + [x] [Anthropic Claude 系列模型](https://anthropic.com)
-   + [x] [Google PaLM2/Gemini 系列模型](https://developers.generativeai.google)
-   + [x] [百度文心一言系列模型](https://cloud.baidu.com/doc/WENXINWORKSHOP/index.html)
-   + [x] [阿里通义千问系列模型](https://help.aliyun.com/document_detail/2400395.html)
-   + [x] [讯飞星火认知大模型](https://www.xfyun.cn/doc/spark/Web.html)
-   + [x] [智谱 ChatGLM 系列模型](https://bigmodel.cn)
-   + [x] [360 智脑](https://ai.360.cn)
-   + [x] [腾讯混元大模型](https://cloud.tencent.com/document/product/1729)
+   - [x] [OpenAI ChatGPT 系列模型](https://platform.openai.com/docs/guides/gpt/chat-completions-api)（支持 [Azure OpenAI API](https://learn.microsoft.com/en-us/azure/ai-services/openai/reference)）
+   - [x] [Anthropic Claude 系列模型](https://anthropic.com)
+   - [x] [Google PaLM2/Gemini 系列模型](https://developers.generativeai.google)
+   - [x] [百度文心一言系列模型](https://cloud.baidu.com/doc/WENXINWORKSHOP/index.html)
+   - [x] [阿里通义千问系列模型](https://help.aliyun.com/document_detail/2400395.html)
+   - [x] [讯飞星火认知大模型](https://www.xfyun.cn/doc/spark/Web.html)
+   - [x] [智谱 ChatGLM 系列模型](https://bigmodel.cn)
+   - [x] [360 智脑](https://ai.360.cn)
+   - [x] [腾讯混元大模型](https://cloud.tencent.com/document/product/1729)
 2. 支持配置镜像以及众多[第三方代理服务](https://iamazing.cn/page/openai-api-third-party-services)。
 3. 支持通过**负载均衡**的方式访问多个渠道。
 4. 支持 **stream 模式**，可以通过流式传输实现打字机效果。
@@ -96,12 +106,14 @@ _✨ 通过标准的 OpenAI API 格式访问所有的大模型，开箱即用
 20. 支持通过系统访问令牌访问管理 API（bearer token，用以替代 cookie，你可以自行抓包来查看 API 的用法）。
 21. 支持 Cloudflare Turnstile 用户校验。
 22. 支持用户管理，支持**多种用户登录注册方式**：
-    + 邮箱登录注册（支持注册邮箱白名单）以及通过邮箱进行密码重置。
-    + [GitHub 开放授权](https://github.com/settings/applications/new)。
-    + 微信公众号授权（需要额外部署 [WeChat Server](https://github.com/songquanpeng/wechat-server)）。
+    - 邮箱登录注册（支持注册邮箱白名单）以及通过邮箱进行密码重置。
+    - [GitHub 开放授权](https://github.com/settings/applications/new)。
+    - 微信公众号授权（需要额外部署 [WeChat Server](https://github.com/songquanpeng/wechat-server)）。
 
 ## 部署
+
 ### 基于 Docker 进行部署
+
 ```shell
 # 使用 SQLite 的部署命令：
 docker run --name one-api -d --restart always -p 3000:3000 -e TZ=Asia/Shanghai -v /home/ubuntu/data/one-api:/data justsong/one-api
@@ -123,10 +135,11 @@ docker run --name one-api -d --restart always -p 3000:3000 -e SQL_DSN="root:1234
 更新命令：`docker run --rm -v /var/run/docker.sock:/var/run/docker.sock containrrr/watchtower -cR`
 
 Nginx 的参考配置：
+
 ```
 server{
    server_name openai.justsong.cn;  # 请根据实际情况修改你的域名
-   
+
    location / {
           client_max_body_size  64m;
           proxy_http_version 1.1;
@@ -141,6 +154,7 @@ server{
 ```
 
 之后使用 Let's Encrypt 的 certbot 配置 HTTPS：
+
 ```bash
 # Ubuntu 安装 certbot：
 sudo snap install --classic certbot
@@ -154,7 +168,6 @@ sudo service nginx restart
 
 初始账号用户名为 `root`，密码为 `123456`。
 
-
 ### 基于 Docker Compose 进行部署
 
 > 仅启动方式不同，参数设置不变，请参考基于 Docker 部署部分
@@ -168,20 +181,23 @@ docker-compose ps
 ```
 
 ### 手动部署
+
 1. 从 [GitHub Releases](https://github.com/songquanpeng/one-api/releases/latest) 下载可执行文件或者从源码编译：
+
    ```shell
    git clone https://github.com/songquanpeng/one-api.git
-   
+
    # 构建前端
    cd one-api/web
    npm install
    npm run build
-   
+
    # 构建后端
    cd ..
    go mod download
    go build -ldflags "-s -w" -o one-api
-   ````
+   ```
+
 2. 运行：
    ```shell
    chmod u+x one-api
@@ -192,6 +208,7 @@ docker-compose ps
 更加详细的部署教程[参见此处](https://iamazing.cn/page/how-to-deploy-a-website)。
 
 ### 多机部署
+
 1. 所有服务器 `SESSION_SECRET` 设置一样的值。
 2. 必须设置 `SQL_DSN`，使用 MySQL 数据库而非 SQLite，所有服务器连接同一个数据库。
 3. 所有从服务器必须设置 `NODE_TYPE` 为 `slave`，不设置则默认为主服务器。
@@ -209,9 +226,11 @@ docker-compose ps
 如果部署后访问出现空白页面，详见 [#97](https://github.com/songquanpeng/one-api/issues/97)。
 
 ### 部署第三方服务配合 One API 使用
+
 > 欢迎 PR 添加更多示例。
 
 #### ChatGPT Next Web
+
 项目主页：https://github.com/Yidadaa/ChatGPT-Next-Web
 
 ```bash
@@ -221,6 +240,7 @@ docker run --name chat-next-web -d -p 3001:3000 yidadaa/chatgpt-next-web
 注意修改端口号，之后在页面上设置接口地址（例如：https://openai.justsong.cn/ ）和 API Key 即可。
 
 #### ChatGPT Web
+
 项目主页：https://github.com/Chanzhaoyu/chatgpt-web
 
 ```bash
@@ -229,14 +249,16 @@ docker run --name chatgpt-web -d -p 3002:3002 -e OPENAI_API_BASE_URL=https://ope
 
 注意修改端口号、`OPENAI_API_BASE_URL` 和 `OPENAI_API_KEY`。
 
-#### QChatGPT - QQ机器人
+#### QChatGPT - QQ 机器人
+
 项目主页：https://github.com/RockChinQ/QChatGPT
 
-根据文档完成部署后，在`config.py`设置配置项`openai_config`的`reverse_proxy`为 One API 后端地址，设置`api_key`为 One API 生成的key，并在配置项`completion_api_params`的`model`参数设置为 One API 支持的模型名称。
+根据文档完成部署后，在`config.py`设置配置项`openai_config`的`reverse_proxy`为 One API 后端地址，设置`api_key`为 One API 生成的 key，并在配置项`completion_api_params`的`model`参数设置为 One API 支持的模型名称。
 
 可安装 [Switcher 插件](https://github.com/RockChinQ/Switcher)在运行时切换所使用的模型。
 
 ### 部署到第三方平台
+
 <details>
 <summary><strong>部署到 Sealos </strong></summary>
 <div>
@@ -261,7 +283,7 @@ docker run --name chatgpt-web -d -p 3002:3002 -e OPENAI_API_BASE_URL=https://ope
 1. 首先 fork 一份代码。
 2. 进入 [Zeabur](https://zeabur.com?referralCode=songquanpeng)，登录，进入控制台。
 3. 新建一个 Project，在 Service -> Add Service 选择 Marketplace，选择 MySQL，并记下连接参数（用户名、密码、地址、端口）。
-4. 复制链接参数，运行 ```create database `one-api` ``` 创建数据库。
+4. 复制链接参数，运行 `` create database `one-api`  `` 创建数据库。
 5. 然后在 Service -> Add Service，选择 Git（第一次使用需要先授权），选择你 fork 的仓库。
 6. Deploy 会自动开始，先取消。进入下方 Variable，添加一个 `PORT`，值为 `3000`，再添加一个 `SQL_DSN`，值为 `<username>:<password>@tcp(<addr>:<port>)/one-api` ，然后保存。 注意如果不填写 `SQL_DSN`，数据将无法持久化，重新部署后数据会丢失。
 7. 选择 Redeploy。
@@ -283,6 +305,7 @@ Render 可以直接部署 docker 镜像，不需要 fork 仓库：https://dashbo
 </details>
 
 ## 配置
+
 系统本身开箱即用。
 
 你可以通过设置环境变量或者命令行参数进行配置。
@@ -292,6 +315,7 @@ Render 可以直接部署 docker 镜像，不需要 fork 仓库：https://dashbo
 **Note**：如果你不知道某个配置项的含义，可以临时删掉值以看到进一步的提示文字。
 
 ## 使用方法
+
 在`渠道`页面中添加你的 API Key，之后在`令牌`页面中新增访问令牌。
 
 之后就可以使用你的令牌访问 One API 了，使用方式与 [OpenAI API](https://platform.openai.com/docs/api-reference/introduction) 一致。
@@ -301,9 +325,10 @@ Render 可以直接部署 docker 镜像，不需要 fork 仓库：https://dashbo
 注意，具体的 API Base 的格式取决于你所使用的客户端。
 
 例如对于 OpenAI 的官方库：
+
 ```bash
 OPENAI_API_KEY="sk-xxxxxx"
-OPENAI_API_BASE="https://<HOST>:<PORT>/v1" 
+OPENAI_API_BASE="https://<HOST>:<PORT>/v1"
 ```
 
 ```mermaid
@@ -322,99 +347,106 @@ graph LR
 不加的话将会使用负载均衡的方式使用多个渠道。
 
 ### 环境变量
+
 1. `REDIS_CONN_STRING`：设置之后将使用 Redis 作为缓存使用。
-   + 例子：`REDIS_CONN_STRING=redis://default:redispw@localhost:49153`
-   + 如果数据库访问延迟很低，没有必要启用 Redis，启用后反而会出现数据滞后的问题。
+   - 例子：`REDIS_CONN_STRING=redis://default:redispw@localhost:49153`
+   - 如果数据库访问延迟很低，没有必要启用 Redis，启用后反而会出现数据滞后的问题。
 2. `SESSION_SECRET`：设置之后将使用固定的会话密钥，这样系统重新启动后已登录用户的 cookie 将依旧有效。
-   + 例子：`SESSION_SECRET=random_string`
+   - 例子：`SESSION_SECRET=random_string`
 3. `SQL_DSN`：设置之后将使用指定数据库而非 SQLite，请使用 MySQL 或 PostgreSQL。
-   + 例子：
-     + MySQL：`SQL_DSN=root:123456@tcp(localhost:3306)/oneapi`
-     + PostgreSQL：`SQL_DSN=postgres://postgres:123456@localhost:5432/oneapi`（适配中，欢迎反馈）
-   + 注意需要提前建立数据库 `oneapi`，无需手动建表，程序将自动建表。
-   + 如果使用本地数据库：部署命令可添加 `--network="host"` 以使得容器内的程序可以访问到宿主机上的 MySQL。
-   + 如果使用云数据库：如果云服务器需要验证身份，需要在连接参数中添加 `?tls=skip-verify`。
-   + 请根据你的数据库配置修改下列参数（或者保持默认值）：
-     + `SQL_MAX_IDLE_CONNS`：最大空闲连接数，默认为 `100`。
-     + `SQL_MAX_OPEN_CONNS`：最大打开连接数，默认为 `1000`。
-       + 如果报错 `Error 1040: Too many connections`，请适当减小该值。
-     + `SQL_CONN_MAX_LIFETIME`：连接的最大生命周期，默认为 `60`，单位分钟。
+   - 例子：
+     - MySQL：`SQL_DSN=root:123456@tcp(localhost:3306)/oneapi`
+     - PostgreSQL：`SQL_DSN=postgres://postgres:123456@localhost:5432/oneapi`（适配中，欢迎反馈）
+   - 注意需要提前建立数据库 `oneapi`，无需手动建表，程序将自动建表。
+   - 如果使用本地数据库：部署命令可添加 `--network="host"` 以使得容器内的程序可以访问到宿主机上的 MySQL。
+   - 如果使用云数据库：如果云服务器需要验证身份，需要在连接参数中添加 `?tls=skip-verify`。
+   - 请根据你的数据库配置修改下列参数（或者保持默认值）：
+     - `SQL_MAX_IDLE_CONNS`：最大空闲连接数，默认为 `100`。
+     - `SQL_MAX_OPEN_CONNS`：最大打开连接数，默认为 `1000`。
+       - 如果报错 `Error 1040: Too many connections`，请适当减小该值。
+     - `SQL_CONN_MAX_LIFETIME`：连接的最大生命周期，默认为 `60`，单位分钟。
 4. `FRONTEND_BASE_URL`：设置之后将重定向页面请求到指定的地址，仅限从服务器设置。
-   + 例子：`FRONTEND_BASE_URL=https://openai.justsong.cn`
+   - 例子：`FRONTEND_BASE_URL=https://openai.justsong.cn`
 5. `MEMORY_CACHE_ENABLED`：启用内存缓存，会导致用户额度的更新存在一定的延迟，可选值为 `true` 和 `false`，未设置则默认为 `false`。
-   + 例子：`MEMORY_CACHE_ENABLED=true`
+   - 例子：`MEMORY_CACHE_ENABLED=true`
 6. `SYNC_FREQUENCY`：在启用缓存的情况下与数据库同步配置的频率，单位为秒，默认为 `600` 秒。
-   + 例子：`SYNC_FREQUENCY=60`
+   - 例子：`SYNC_FREQUENCY=60`
 7. `NODE_TYPE`：设置之后将指定节点类型，可选值为 `master` 和 `slave`，未设置则默认为 `master`。
-   + 例子：`NODE_TYPE=slave`
+   - 例子：`NODE_TYPE=slave`
 8. `CHANNEL_UPDATE_FREQUENCY`：设置之后将定期更新渠道余额，单位为分钟，未设置则不进行更新。
-   + 例子：`CHANNEL_UPDATE_FREQUENCY=1440`
+   - 例子：`CHANNEL_UPDATE_FREQUENCY=1440`
 9. `CHANNEL_TEST_FREQUENCY`：设置之后将定期检查渠道，单位为分钟，未设置则不进行检查。
-   + 例子：`CHANNEL_TEST_FREQUENCY=1440`
+   - 例子：`CHANNEL_TEST_FREQUENCY=1440`
 10. `POLLING_INTERVAL`：批量更新渠道余额以及测试可用性时的请求间隔，单位为秒，默认无间隔。
-    + 例子：`POLLING_INTERVAL=5`
+    - 例子：`POLLING_INTERVAL=5`
 11. `BATCH_UPDATE_ENABLED`：启用数据库批量更新聚合，会导致用户额度的更新存在一定的延迟可选值为 `true` 和 `false`，未设置则默认为 `false`。
-    + 例子：`BATCH_UPDATE_ENABLED=true`
-    + 如果你遇到了数据库连接数过多的问题，可以尝试启用该选项。
+    - 例子：`BATCH_UPDATE_ENABLED=true`
+    - 如果你遇到了数据库连接数过多的问题，可以尝试启用该选项。
 12. `BATCH_UPDATE_INTERVAL=5`：批量更新聚合的时间间隔，单位为秒，默认为 `5`。
-    + 例子：`BATCH_UPDATE_INTERVAL=5`
+    - 例子：`BATCH_UPDATE_INTERVAL=5`
 13. 请求频率限制：
-    + `GLOBAL_API_RATE_LIMIT`：全局 API 速率限制（除中继请求外），单 ip 三分钟内的最大请求数，默认为 `180`。
-    + `GLOBAL_WEB_RATE_LIMIT`：全局 Web 速率限制，单 ip 三分钟内的最大请求数，默认为 `60`。
+    - `GLOBAL_API_RATE_LIMIT`：全局 API 速率限制（除中继请求外），单 ip 三分钟内的最大请求数，默认为 `180`。
+    - `GLOBAL_WEB_RATE_LIMIT`：全局 Web 速率限制，单 ip 三分钟内的最大请求数，默认为 `60`。
 14. 编码器缓存设置：
-    + `TIKTOKEN_CACHE_DIR`：默认程序启动时会联网下载一些通用的词元的编码，如：`gpt-3.5-turbo`，在一些网络环境不稳定，或者离线情况，可能会导致启动有问题，可以配置此目录缓存数据，可迁移到离线环境。
-    + `DATA_GYM_CACHE_DIR`：目前该配置作用与 `TIKTOKEN_CACHE_DIR` 一致，但是优先级没有它高。
+    - `TIKTOKEN_CACHE_DIR`：默认程序启动时会联网下载一些通用的词元的编码，如：`gpt-3.5-turbo`，在一些网络环境不稳定，或者离线情况，可能会导致启动有问题，可以配置此目录缓存数据，可迁移到离线环境。
+    - `DATA_GYM_CACHE_DIR`：目前该配置作用与 `TIKTOKEN_CACHE_DIR` 一致，但是优先级没有它高。
 15. `RELAY_TIMEOUT`：中继超时设置，单位为秒，默认不设置超时时间。
 16. `SQLITE_BUSY_TIMEOUT`：SQLite 锁等待超时设置，单位为毫秒，默认 `3000`。
 
 ### 命令行参数
+
 1. `--port <port_number>`: 指定服务器监听的端口号，默认为 `3000`。
-   + 例子：`--port 3000`
+   - 例子：`--port 3000`
 2. `--log-dir <log_dir>`: 指定日志文件夹，如果没有设置，默认保存至工作目录的 `logs` 文件夹下。
-   + 例子：`--log-dir ./logs`
+   - 例子：`--log-dir ./logs`
 3. `--version`: 打印系统版本号并退出。
 4. `--help`: 查看命令的使用帮助和参数说明。
 
 ## 演示
+
 ### 在线演示
+
 注意，该演示站不提供对外服务：
 https://openai.justsong.cn
 
 ### 截图展示
+
 ![channel](https://user-images.githubusercontent.com/39998050/233837954-ae6683aa-5c4f-429f-a949-6645a83c9490.png)
 ![token](https://user-images.githubusercontent.com/39998050/233837971-dab488b7-6d96-43af-b640-a168e8d1c9bf.png)
 
 ## 常见问题
+
 1. 额度是什么？怎么计算的？One API 的额度计算有问题？
-   + 额度 = 分组倍率 * 模型倍率 * （提示 token 数 + 补全 token 数 * 补全倍率）
-   + 其中补全倍率对于 GPT3.5 固定为 1.33，GPT4 为 2，与官方保持一致。
-   + 如果是非流模式，官方接口会返回消耗的总 token，但是你要注意提示和补全的消耗倍率不一样。
-   + 注意，One API 的默认倍率就是官方倍率，是已经调整过的。
+   - 额度 = 分组倍率 _ 模型倍率 _ （提示 token 数 + 补全 token 数 \* 补全倍率）
+   - 其中补全倍率对于 GPT3.5 固定为 1.33，GPT4 为 2，与官方保持一致。
+   - 如果是非流模式，官方接口会返回消耗的总 token，但是你要注意提示和补全的消耗倍率不一样。
+   - 注意，One API 的默认倍率就是官方倍率，是已经调整过的。
 2. 账户额度足够为什么提示额度不足？
-   + 请检查你的令牌额度是否足够，这个和账户额度是分开的。
-   + 令牌额度仅供用户设置最大使用量，用户可自由设置。
+   - 请检查你的令牌额度是否足够，这个和账户额度是分开的。
+   - 令牌额度仅供用户设置最大使用量，用户可自由设置。
 3. 提示无可用渠道？
-   + 请检查的用户分组和渠道分组设置。
-   + 以及渠道的模型设置。
+   - 请检查的用户分组和渠道分组设置。
+   - 以及渠道的模型设置。
 4. 渠道测试报错：`invalid character '<' looking for beginning of value`
-   + 这是因为返回值不是合法的 JSON，而是一个 HTML 页面。
-   + 大概率是你的部署站的 IP 或代理的节点被 CloudFlare 封禁了。
+   - 这是因为返回值不是合法的 JSON，而是一个 HTML 页面。
+   - 大概率是你的部署站的 IP 或代理的节点被 CloudFlare 封禁了。
 5. ChatGPT Next Web 报错：`Failed to fetch`
-   + 部署的时候不要设置 `BASE_URL`。
-   + 检查你的接口地址和 API Key 有没有填对。
-   + 检查是否启用了 HTTPS，浏览器会拦截 HTTPS 域名下的 HTTP 请求。
+   - 部署的时候不要设置 `BASE_URL`。
+   - 检查你的接口地址和 API Key 有没有填对。
+   - 检查是否启用了 HTTPS，浏览器会拦截 HTTPS 域名下的 HTTP 请求。
 6. 报错：`当前分组负载已饱和，请稍后再试`
-   + 上游通道 429 了。
+   - 上游通道 429 了。
 7. 升级之后我的数据会丢失吗？
-   + 如果使用 MySQL，不会。
-   + 如果使用 SQLite，需要按照我所给的部署命令挂载 volume 持久化 one-api.db 数据库文件，否则容器重启后数据会丢失。
+   - 如果使用 MySQL，不会。
+   - 如果使用 SQLite，需要按照我所给的部署命令挂载 volume 持久化 one-api.db 数据库文件，否则容器重启后数据会丢失。
 8. 升级之前数据库需要做变更吗？
-   + 一般情况下不需要，系统将在初始化的时候自动调整。
-   + 如果需要的话，我会在更新日志中说明，并给出脚本。
+   - 一般情况下不需要，系统将在初始化的时候自动调整。
+   - 如果需要的话，我会在更新日志中说明，并给出脚本。
 
 ## 相关项目
-* [FastGPT](https://github.com/labring/FastGPT): 基于 LLM 大语言模型的知识库问答系统
-* [ChatGPT Next Web](https://github.com/Yidadaa/ChatGPT-Next-Web):  一键拥有你自己的跨平台 ChatGPT 应用
+
+- [FastGPT](https://github.com/labring/FastGPT): 基于 LLM 大语言模型的知识库问答系统
+- [ChatGPT Next Web](https://github.com/Yidadaa/ChatGPT-Next-Web): 一键拥有你自己的跨平台 ChatGPT 应用
 
 ## 注意
 

common/client.go

@@ -0,0 +1,299 @@
+package common
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"one-api/types"
+	"strconv"
+	"sync"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"golang.org/x/net/proxy"
+)
+
+var clientPool = &sync.Pool{
+	New: func() interface{} {
+		return &http.Client{}
+	},
+}
+
+func GetHttpClient(proxyAddr string) *http.Client {
+	client := clientPool.Get().(*http.Client)
+
+	if RelayTimeout > 0 {
+		client.Timeout = time.Duration(RelayTimeout) * time.Second
+	}
+
+	if proxyAddr != "" {
+		proxyURL, err := url.Parse(proxyAddr)
+		if err != nil {
+			SysError("Error parsing proxy address: " + err.Error())
+			return client
+		}
+
+		switch proxyURL.Scheme {
+		case "http", "https":
+			client.Transport = &http.Transport{
+				Proxy: http.ProxyURL(proxyURL),
+			}
+		case "socks5":
+			dialer, err := proxy.SOCKS5("tcp", proxyURL.Host, nil, proxy.Direct)
+			if err != nil {
+				SysError("Error creating SOCKS5 dialer: " + err.Error())
+				return client
+			}
+			client.Transport = &http.Transport{
+				Dial: dialer.Dial,
+			}
+		default:
+			SysError("Unsupported proxy scheme: " + proxyURL.Scheme)
+		}
+	}
+
+	return client
+
+}
+
+func PutHttpClient(c *http.Client) {
+	clientPool.Put(c)
+}
+
+type Client struct {
+	requestBuilder    RequestBuilder
+	CreateFormBuilder func(io.Writer) FormBuilder
+}
+
+func NewClient() *Client {
+	return &Client{
+		requestBuilder: NewRequestBuilder(),
+		CreateFormBuilder: func(body io.Writer) FormBuilder {
+			return NewFormBuilder(body)
+		},
+	}
+}
+
+type requestOptions struct {
+	body   any
+	header http.Header
+}
+
+type requestOption func(*requestOptions)
+
+type Stringer interface {
+	GetString() *string
+}
+
+func WithBody(body any) requestOption {
+	return func(args *requestOptions) {
+		args.body = body
+	}
+}
+
+func WithHeader(header map[string]string) requestOption {
+	return func(args *requestOptions) {
+		for k, v := range header {
+			args.header.Set(k, v)
+		}
+	}
+}
+
+func WithContentType(contentType string) requestOption {
+	return func(args *requestOptions) {
+		args.header.Set("Content-Type", contentType)
+	}
+}
+
+type RequestError struct {
+	HTTPStatusCode int
+	Err            error
+}
+
+func (c *Client) NewRequest(method, url string, setters ...requestOption) (*http.Request, error) {
+	// Default Options
+	args := &requestOptions{
+		body:   nil,
+		header: make(http.Header),
+	}
+	for _, setter := range setters {
+		setter(args)
+	}
+	req, err := c.requestBuilder.Build(method, url, args.body, args.header)
+	if err != nil {
+		return nil, err
+	}
+
+	return req, nil
+}
+
+func SendRequest(req *http.Request, response any, outputResp bool, proxyAddr string) (*http.Response, *types.OpenAIErrorWithStatusCode) {
+	// 发送请求
+	client := GetHttpClient(proxyAddr)
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, ErrorWrapper(err, "http_request_failed", http.StatusInternalServerError)
+	}
+	PutHttpClient(client)
+
+	if !outputResp {
+		defer resp.Body.Close()
+	}
+
+	// 处理响应
+	if IsFailureStatusCode(resp) {
+		return nil, HandleErrorResp(resp)
+	}
+
+	// 解析响应
+	if outputResp {
+		var buf bytes.Buffer
+		tee := io.TeeReader(resp.Body, &buf)
+		err = DecodeResponse(tee, response)
+
+		// 将响应体重新写入 resp.Body
+		resp.Body = io.NopCloser(&buf)
+	} else {
+		err = DecodeResponse(resp.Body, response)
+	}
+	if err != nil {
+		return nil, ErrorWrapper(err, "decode_response_failed", http.StatusInternalServerError)
+	}
+
+	if outputResp {
+		return resp, nil
+	}
+
+	return nil, nil
+}
+
+type GeneralErrorResponse struct {
+	Error    types.OpenAIError `json:"error"`
+	Message  string            `json:"message"`
+	Msg      string            `json:"msg"`
+	Err      string            `json:"err"`
+	ErrorMsg string            `json:"error_msg"`
+	Header   struct {
+		Message string `json:"message"`
+	} `json:"header"`
+	Response struct {
+		Error struct {
+			Message string `json:"message"`
+		} `json:"error"`
+	} `json:"response"`
+}
+
+func (e GeneralErrorResponse) ToMessage() string {
+	if e.Error.Message != "" {
+		return e.Error.Message
+	}
+	if e.Message != "" {
+		return e.Message
+	}
+	if e.Msg != "" {
+		return e.Msg
+	}
+	if e.Err != "" {
+		return e.Err
+	}
+	if e.ErrorMsg != "" {
+		return e.ErrorMsg
+	}
+	if e.Header.Message != "" {
+		return e.Header.Message
+	}
+	if e.Response.Error.Message != "" {
+		return e.Response.Error.Message
+	}
+	return ""
+}
+
+// 处理错误响应
+func HandleErrorResp(resp *http.Response) (openAIErrorWithStatusCode *types.OpenAIErrorWithStatusCode) {
+	openAIErrorWithStatusCode = &types.OpenAIErrorWithStatusCode{
+		StatusCode: resp.StatusCode,
+		OpenAIError: types.OpenAIError{
+			Message: "",
+			Type:    "upstream_error",
+			Code:    "bad_response_status_code",
+			Param:   strconv.Itoa(resp.StatusCode),
+		},
+	}
+	responseBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return
+	}
+	err = resp.Body.Close()
+	if err != nil {
+		return
+	}
+	// var errorResponse types.OpenAIErrorResponse
+	var errorResponse GeneralErrorResponse
+	err = json.Unmarshal(responseBody, &errorResponse)
+	if err != nil {
+		return
+	}
+
+	if errorResponse.Error.Message != "" {
+		// OpenAI format error, so we override the default one
+		openAIErrorWithStatusCode.OpenAIError = errorResponse.Error
+	} else {
+		openAIErrorWithStatusCode.OpenAIError.Message = errorResponse.ToMessage()
+	}
+	if openAIErrorWithStatusCode.OpenAIError.Message == "" {
+		openAIErrorWithStatusCode.OpenAIError.Message = fmt.Sprintf("bad response status code %d", resp.StatusCode)
+	}
+
+	return
+}
+
+func (c *Client) SendRequestRaw(req *http.Request, proxyAddr string) (body io.ReadCloser, err error) {
+	client := GetHttpClient(proxyAddr)
+	resp, err := client.Do(req)
+	PutHttpClient(client)
+	if err != nil {
+		return
+	}
+
+	return resp.Body, nil
+}
+
+func IsFailureStatusCode(resp *http.Response) bool {
+	return resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusBadRequest
+}
+
+func DecodeResponse(body io.Reader, v any) error {
+	if v == nil {
+		return nil
+	}
+
+	if result, ok := v.(*string); ok {
+		return DecodeString(body, result)
+	}
+
+	if stringer, ok := v.(Stringer); ok {
+		return DecodeString(body, stringer.GetString())
+	}
+
+	return json.NewDecoder(body).Decode(v)
+}
+
+func DecodeString(body io.Reader, output *string) error {
+	b, err := io.ReadAll(body)
+	if err != nil {
+		return err
+	}
+	*output = string(b)
+	return nil
+}
+
+func SetEventStreamHeaders(c *gin.Context) {
+	c.Writer.Header().Set("Content-Type", "text/event-stream")
+	c.Writer.Header().Set("Cache-Control", "no-cache")
+	c.Writer.Header().Set("Connection", "keep-alive")
+	c.Writer.Header().Set("Transfer-Encoding", "chunked")
+	c.Writer.Header().Set("X-Accel-Buffering", "no")
+}

common/constants.go

@@ -122,7 +122,7 @@ var (
 	GlobalApiRateLimitNum            = GetOrDefault("GLOBAL_API_RATE_LIMIT", 180)
 	GlobalApiRateLimitDuration int64 = 3 * 60
 
-	GlobalWebRateLimitNum            = GetOrDefault("GLOBAL_WEB_RATE_LIMIT", 60)
+	GlobalWebRateLimitNum            = GetOrDefault("GLOBAL_WEB_RATE_LIMIT", 100)
 	GlobalWebRateLimitDuration int64 = 3 * 60
 
 	UploadRateLimitNum            = 10
@@ -187,7 +187,8 @@ const (
 	ChannelTypeAIProxyLibrary = 21
 	ChannelTypeFastGPT        = 22
 	ChannelTypeTencent        = 23
-	ChannelTypeGemini         = 24
+	ChannelTypeAzureSpeech    = 24
+	ChannelTypeGemini         = 25
 )
 
 var ChannelBaseURLs = []string{
@@ -216,4 +217,20 @@ var ChannelBaseURLs = []string{
 	"https://fastgpt.run/api/openapi",   // 22
 	"https://hunyuan.cloud.tencent.com", //23
 	"",                                  //24
+	"",                                  //25
 }
+
+const (
+	RelayModeUnknown = iota
+	RelayModeChatCompletions
+	RelayModeCompletions
+	RelayModeEmbeddings
+	RelayModeModerations
+	RelayModeImagesGenerations
+	RelayModeImagesEdits
+	RelayModeImagesVariations
+	RelayModeEdits
+	RelayModeAudioSpeech
+	RelayModeAudioTranscription
+	RelayModeAudioTranslation
+)

common/form_builder.go

@@ -0,0 +1,71 @@
+package common
+
+import (
+	"fmt"
+	"io"
+	"mime/multipart"
+	"path"
+)
+
+type FormBuilder interface {
+	CreateFormFile(fieldname string, fileHeader *multipart.FileHeader) error
+	CreateFormFileReader(fieldname string, r io.Reader, filename string) error
+	WriteField(fieldname, value string) error
+	Close() error
+	FormDataContentType() string
+}
+
+type DefaultFormBuilder struct {
+	writer *multipart.Writer
+}
+
+func NewFormBuilder(body io.Writer) *DefaultFormBuilder {
+	return &DefaultFormBuilder{
+		writer: multipart.NewWriter(body),
+	}
+}
+
+func (fb *DefaultFormBuilder) CreateFormFile(fieldname string, fileHeader *multipart.FileHeader) error {
+	file, err := fileHeader.Open()
+	if err != nil {
+		return err
+	}
+
+	defer file.Close()
+
+	return fb.createFormFile(fieldname, file, fileHeader.Filename)
+}
+
+func (fb *DefaultFormBuilder) CreateFormFileReader(fieldname string, r io.Reader, filename string) error {
+	return fb.createFormFile(fieldname, r, path.Base(filename))
+}
+
+func (fb *DefaultFormBuilder) createFormFile(fieldname string, r io.Reader, filename string) error {
+	if filename == "" {
+		return fmt.Errorf("filename cannot be empty")
+	}
+
+	fieldWriter, err := fb.writer.CreateFormFile(fieldname, filename)
+	if err != nil {
+		return err
+	}
+
+	_, err = io.Copy(fieldWriter, r)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (fb *DefaultFormBuilder) WriteField(fieldname, value string) error {
+	return fb.writer.WriteField(fieldname, value)
+}
+
+func (fb *DefaultFormBuilder) Close() error {
+	return fb.writer.Close()
+}
+
+func (fb *DefaultFormBuilder) FormDataContentType() string {
+	return fb.writer.FormDataContentType()
+}

common/gin.go

@@ -2,10 +2,12 @@ package common
 
 import (
 	"bytes"
-	"encoding/json"
-	"github.com/gin-gonic/gin"
+	"fmt"
 	"io"
-	"strings"
+	"one-api/types"
+
+	"github.com/gin-gonic/gin"
+	"github.com/go-playground/validator/v10"
 )
 
 func UnmarshalBodyReusable(c *gin.Context, v any) error {
@@ -17,17 +19,43 @@ func UnmarshalBodyReusable(c *gin.Context, v any) error {
 	if err != nil {
 		return err
 	}
-	contentType := c.Request.Header.Get("Content-Type")
-	if strings.HasPrefix(contentType, "application/json") {
-		err = json.Unmarshal(requestBody, &v)
-	} else {
-		// skip for now
-		// TODO: someday non json request have variant model, we will need to implementation this
-	}
+	c.Request.Body = io.NopCloser(bytes.NewBuffer(requestBody))
+	err = c.ShouldBind(v)
 	if err != nil {
+		if errs, ok := err.(validator.ValidationErrors); ok {
+			// 返回第一个错误字段的名称
+			return fmt.Errorf("field %s is required", errs[0].Field())
+		}
 		return err
 	}
-	// Reset request body
+
 	c.Request.Body = io.NopCloser(bytes.NewBuffer(requestBody))
 	return nil
 }
+
+func ErrorWrapper(err error, code string, statusCode int) *types.OpenAIErrorWithStatusCode {
+	return StringErrorWrapper(err.Error(), code, statusCode)
+}
+
+func StringErrorWrapper(err string, code string, statusCode int) *types.OpenAIErrorWithStatusCode {
+	openAIError := types.OpenAIError{
+		Message: err,
+		Type:    "one_api_error",
+		Code:    code,
+	}
+	return &types.OpenAIErrorWithStatusCode{
+		OpenAIError: openAIError,
+		StatusCode:  statusCode,
+	}
+}
+
+func AbortWithMessage(c *gin.Context, statusCode int, message string) {
+	c.JSON(statusCode, gin.H{
+		"error": gin.H{
+			"message": message,
+			"type":    "one_api_error",
+		},
+	})
+	c.Abort()
+	LogError(c.Request.Context(), message)
+}

common/init.go

@@ -6,6 +6,8 @@ import (
 	"log"
 	"os"
 	"path/filepath"
+
+	"github.com/joho/godotenv"
 )
 
 var (
@@ -23,6 +25,11 @@ func printHelp() {
 }
 
 func init() {
+	// 加载.env文件
+	err := godotenv.Load()
+	if err != nil {
+		SysLog("failed to load .env file: " + err.Error())
+	}
 	flag.Parse()
 
 	if *PrintVersion {

common/marshaller.go

@@ -0,0 +1,15 @@
+package common
+
+import (
+	"encoding/json"
+)
+
+type Marshaller interface {
+	Marshal(value any) ([]byte, error)
+}
+
+type JSONMarshaller struct{}
+
+func (jm *JSONMarshaller) Marshal(value any) ([]byte, error) {
+	return json.Marshal(value)
+}

common/quota.go

@@ -0,0 +1,59 @@
+package common
+
+// type Quota struct {
+// 	ModelName  string
+// 	ModelRatio float64
+// 	GroupRatio float64
+// 	Ratio      float64
+// 	UserQuota  int
+// }
+
+// func CreateQuota(modelName string, userQuota int, group string) *Quota {
+// 	modelRatio := GetModelRatio(modelName)
+// 	groupRatio := GetGroupRatio(group)
+
+// 	return &Quota{
+// 		ModelName:  modelName,
+// 		ModelRatio: modelRatio,
+// 		GroupRatio: groupRatio,
+// 		Ratio:      modelRatio * groupRatio,
+// 		UserQuota:  userQuota,
+// 	}
+// }
+
+// func (q *Quota) getTokenNum(tokenEncoder *tiktoken.Tiktoken, text string) int {
+// 	if ApproximateTokenEnabled {
+// 		return int(float64(len(text)) * 0.38)
+// 	}
+// 	return len(tokenEncoder.Encode(text, nil, nil))
+// }
+
+// func (q *Quota) CountTokenMessages(messages []Message, model string) int {
+// 	tokenEncoder := q.getTokenEncoder(model)
+// 	// Reference:
+// 	// https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
+// 	// https://github.com/pkoukk/tiktoken-go/issues/6
+// 	//
+// 	// Every message follows <|start|>{role/name}\n{content}<|end|>\n
+// 	var tokensPerMessage int
+// 	var tokensPerName int
+// 	if model == "gpt-3.5-turbo-0301" {
+// 		tokensPerMessage = 4
+// 		tokensPerName = -1 // If there's a name, the role is omitted
+// 	} else {
+// 		tokensPerMessage = 3
+// 		tokensPerName = 1
+// 	}
+// 	tokenNum := 0
+// 	for _, message := range messages {
+// 		tokenNum += tokensPerMessage
+// 		tokenNum += q.getTokenNum(tokenEncoder, message.StringContent())
+// 		tokenNum += q.getTokenNum(tokenEncoder, message.Role)
+// 		if message.Name != nil {
+// 			tokenNum += tokensPerName
+// 			tokenNum += q.getTokenNum(tokenEncoder, *message.Name)
+// 		}
+// 	}
+// 	tokenNum += 3 // Every reply is primed with <|start|>assistant<|message|>
+// 	return tokenNum
+// }

common/request_builder.go

@@ -0,0 +1,50 @@
+package common
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+)
+
+type RequestBuilder interface {
+	Build(method, url string, body any, header http.Header) (*http.Request, error)
+}
+
+type HTTPRequestBuilder struct {
+	marshaller Marshaller
+}
+
+func NewRequestBuilder() *HTTPRequestBuilder {
+	return &HTTPRequestBuilder{
+		marshaller: &JSONMarshaller{},
+	}
+}
+
+func (b *HTTPRequestBuilder) Build(
+	method string,
+	url string,
+	body any,
+	header http.Header,
+) (req *http.Request, err error) {
+	var bodyReader io.Reader
+	if body != nil {
+		if v, ok := body.(io.Reader); ok {
+			bodyReader = v
+		} else {
+			var reqBytes []byte
+			reqBytes, err = b.marshaller.Marshal(body)
+			if err != nil {
+				return
+			}
+			bodyReader = bytes.NewBuffer(reqBytes)
+		}
+	}
+	req, err = http.NewRequest(method, url, bodyReader)
+	if err != nil {
+		return
+	}
+	if header != nil {
+		req.Header = header
+	}
+	return
+}

common/token.go

@@ -0,0 +1,238 @@
+package common
+
+import (
+	"errors"
+	"fmt"
+	"math"
+	"strings"
+
+	"one-api/common/image"
+	"one-api/types"
+
+	"github.com/pkoukk/tiktoken-go"
+)
+
+var tokenEncoderMap = map[string]*tiktoken.Tiktoken{}
+var defaultTokenEncoder *tiktoken.Tiktoken
+
+func InitTokenEncoders() {
+	SysLog("initializing token encoders")
+	gpt35TokenEncoder, err := tiktoken.EncodingForModel("gpt-3.5-turbo")
+	if err != nil {
+		FatalLog(fmt.Sprintf("failed to get gpt-3.5-turbo token encoder: %s", err.Error()))
+	}
+	defaultTokenEncoder = gpt35TokenEncoder
+	gpt4TokenEncoder, err := tiktoken.EncodingForModel("gpt-4")
+	if err != nil {
+		FatalLog(fmt.Sprintf("failed to get gpt-4 token encoder: %s", err.Error()))
+	}
+	for model, _ := range ModelRatio {
+		if strings.HasPrefix(model, "gpt-3.5") {
+			tokenEncoderMap[model] = gpt35TokenEncoder
+		} else if strings.HasPrefix(model, "gpt-4") {
+			tokenEncoderMap[model] = gpt4TokenEncoder
+		} else {
+			tokenEncoderMap[model] = nil
+		}
+	}
+	SysLog("token encoders initialized")
+}
+
+func getTokenEncoder(model string) *tiktoken.Tiktoken {
+	tokenEncoder, ok := tokenEncoderMap[model]
+	if ok && tokenEncoder != nil {
+		return tokenEncoder
+	}
+	if ok {
+		tokenEncoder, err := tiktoken.EncodingForModel(model)
+		if err != nil {
+			SysError(fmt.Sprintf("failed to get token encoder for model %s: %s, using encoder for gpt-3.5-turbo", model, err.Error()))
+			tokenEncoder = defaultTokenEncoder
+		}
+		tokenEncoderMap[model] = tokenEncoder
+		return tokenEncoder
+	}
+	return defaultTokenEncoder
+}
+
+func getTokenNum(tokenEncoder *tiktoken.Tiktoken, text string) int {
+	if ApproximateTokenEnabled {
+		return int(float64(len(text)) * 0.38)
+	}
+	return len(tokenEncoder.Encode(text, nil, nil))
+}
+
+func CountTokenMessages(messages []types.ChatCompletionMessage, model string) int {
+	tokenEncoder := getTokenEncoder(model)
+	// Reference:
+	// https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
+	// https://github.com/pkoukk/tiktoken-go/issues/6
+	//
+	// Every message follows <|start|>{role/name}\n{content}<|end|>\n
+	var tokensPerMessage int
+	var tokensPerName int
+	if model == "gpt-3.5-turbo-0301" {
+		tokensPerMessage = 4
+		tokensPerName = -1 // If there's a name, the role is omitted
+	} else {
+		tokensPerMessage = 3
+		tokensPerName = 1
+	}
+	tokenNum := 0
+	for _, message := range messages {
+		tokenNum += tokensPerMessage
+		switch v := message.Content.(type) {
+		case string:
+			tokenNum += getTokenNum(tokenEncoder, v)
+		case []any:
+			for _, it := range v {
+				m := it.(map[string]any)
+				switch m["type"] {
+				case "text":
+					tokenNum += getTokenNum(tokenEncoder, m["text"].(string))
+				case "image_url":
+					imageUrl, ok := m["image_url"].(map[string]any)
+					if ok {
+						url := imageUrl["url"].(string)
+						detail := ""
+						if imageUrl["detail"] != nil {
+							detail = imageUrl["detail"].(string)
+						}
+						imageTokens, err := countImageTokens(url, detail)
+						if err != nil {
+							SysError("error counting image tokens: " + err.Error())
+						} else {
+							tokenNum += imageTokens
+						}
+					}
+				}
+			}
+		}
+		tokenNum += getTokenNum(tokenEncoder, message.StringContent())
+		tokenNum += getTokenNum(tokenEncoder, message.Role)
+		if message.Name != nil {
+			tokenNum += tokensPerName
+			tokenNum += getTokenNum(tokenEncoder, *message.Name)
+		}
+	}
+	tokenNum += 3 // Every reply is primed with <|start|>assistant<|message|>
+	return tokenNum
+}
+
+const (
+	lowDetailCost         = 85
+	highDetailCostPerTile = 170
+	additionalCost        = 85
+)
+
+// https://platform.openai.com/docs/guides/vision/calculating-costs
+// https://github.com/openai/openai-cookbook/blob/05e3f9be4c7a2ae7ecf029a7c32065b024730ebe/examples/How_to_count_tokens_with_tiktoken.ipynb
+func countImageTokens(url string, detail string) (_ int, err error) {
+	var fetchSize = true
+	var width, height int
+	// Reference: https://platform.openai.com/docs/guides/vision/low-or-high-fidelity-image-understanding
+	// detail == "auto" is undocumented on how it works, it just said the model will use the auto setting which will look at the image input size and decide if it should use the low or high setting.
+	// According to the official guide, "low" disable the high-res model,
+	// and only receive low-res 512px x 512px version of the image, indicating
+	// that image is treated as low-res when size is smaller than 512px x 512px,
+	// then we can assume that image size larger than 512px x 512px is treated
+	// as high-res. Then we have the following logic:
+	// if detail == "" || detail == "auto" {
+	// 	width, height, err = image.GetImageSize(url)
+	// 	if err != nil {
+	// 		return 0, err
+	// 	}
+	// 	fetchSize = false
+	// 	// not sure if this is correct
+	// 	if width > 512 || height > 512 {
+	// 		detail = "high"
+	// 	} else {
+	// 		detail = "low"
+	// 	}
+	// }
+
+	// However, in my test, it seems to be always the same as "high".
+	// The following image, which is 125x50, is still treated as high-res, taken
+	// 255 tokens in the response of non-stream chat completion api.
+	// https://upload.wikimedia.org/wikipedia/commons/1/10/18_Infantry_Division_Messina.jpg
+	if detail == "" || detail == "auto" {
+		// assume by test, not sure if this is correct
+		detail = "high"
+	}
+	switch detail {
+	case "low":
+		return lowDetailCost, nil
+	case "high":
+		if fetchSize {
+			width, height, err = image.GetImageSize(url)
+			if err != nil {
+				return 0, err
+			}
+		}
+		if width > 2048 || height > 2048 { // max(width, height) > 2048
+			ratio := float64(2048) / math.Max(float64(width), float64(height))
+			width = int(float64(width) * ratio)
+			height = int(float64(height) * ratio)
+		}
+		if width > 768 && height > 768 { // min(width, height) > 768
+			ratio := float64(768) / math.Min(float64(width), float64(height))
+			width = int(float64(width) * ratio)
+			height = int(float64(height) * ratio)
+		}
+		numSquares := int(math.Ceil(float64(width)/512) * math.Ceil(float64(height)/512))
+		result := numSquares*highDetailCostPerTile + additionalCost
+		return result, nil
+	default:
+		return 0, errors.New("invalid detail option")
+	}
+}
+
+func CountTokenInput(input any, model string) int {
+	switch v := input.(type) {
+	case string:
+		return CountTokenInput(v, model)
+	case []string:
+		text := ""
+		for _, s := range v {
+			text += s
+		}
+		return CountTokenInput(text, model)
+	}
+	return 0
+}
+
+func CountTokenText(text string, model string) int {
+	tokenEncoder := getTokenEncoder(model)
+	return getTokenNum(tokenEncoder, text)
+}
+
+func CountTokenImage(input interface{}) (int, error) {
+	switch v := input.(type) {
+	case types.ImageRequest:
+		// 处理 ImageRequest
+		return calculateToken(v.Model, v.Size, v.N, v.Quality)
+	case types.ImageEditRequest:
+		// 处理 ImageEditsRequest
+		return calculateToken(v.Model, v.Size, v.N, "")
+	default:
+		return 0, errors.New("unsupported type")
+	}
+}
+
+func calculateToken(model string, size string, n int, quality string) (int, error) {
+	imageCostRatio, hasValidSize := DalleSizeRatios[model][size]
+
+	if hasValidSize {
+		if quality == "hd" && model == "dall-e-3" {
+			if size == "1024x1024" {
+				imageCostRatio *= 2
+			} else {
+				imageCostRatio *= 1.5
+			}
+		}
+	} else {
+		return 0, errors.New("size not supported for this image model")
+	}
+
+	return int(imageCostRatio*1000) * n, nil
+}

controller/billing.go

@@ -1,9 +1,11 @@
 package controller
 
 import (
-	"github.com/gin-gonic/gin"
 	"one-api/common"
 	"one-api/model"
+	"one-api/types"
+
+	"github.com/gin-gonic/gin"
 )
 
 func GetSubscription(c *gin.Context) {
@@ -21,13 +23,23 @@ func GetSubscription(c *gin.Context) {
 	} else {
 		userId := c.GetInt("id")
 		remainQuota, err = model.GetUserQuota(userId)
+		if err != nil {
+			openAIError := types.OpenAIError{
+				Message: err.Error(),
+				Type:    "upstream_error",
+			}
+			c.JSON(200, gin.H{
+				"error": openAIError,
+			})
+			return
+		}
 		usedQuota, err = model.GetUserUsedQuota(userId)
 	}
 	if expiredTime <= 0 {
 		expiredTime = 0
 	}
 	if err != nil {
-		openAIError := OpenAIError{
+		openAIError := types.OpenAIError{
 			Message: err.Error(),
 			Type:    "upstream_error",
 		}
@@ -53,7 +65,6 @@ func GetSubscription(c *gin.Context) {
 		AccessUntil:        expiredTime,
 	}
 	c.JSON(200, subscription)
-	return
 }
 
 func GetUsage(c *gin.Context) {
@@ -69,7 +80,7 @@ func GetUsage(c *gin.Context) {
 		quota, err = model.GetUserUsedQuota(userId)
 	}
 	if err != nil {
-		openAIError := OpenAIError{
+		openAIError := types.OpenAIError{
 			Message: err.Error(),
 			Type:    "one_api_error",
 		}
@@ -87,5 +98,4 @@ func GetUsage(c *gin.Context) {
 		TotalUsage: amount * 100,
 	}
 	c.JSON(200, usage)
-	return
 }

controller/channel-billing.go

@@ -1,13 +1,13 @@
 package controller
 
 import (
-	"encoding/json"
 	"errors"
-	"fmt"
-	"io"
 	"net/http"
+	"net/http/httptest"
 	"one-api/common"
 	"one-api/model"
+	"one-api/providers"
+	providersBase "one-api/providers/base"
 	"strconv"
 	"time"
 
@@ -46,216 +46,29 @@ type OpenAIUsageResponse struct {
 	TotalUsage float64 `json:"total_usage"` // unit: 0.01 dollar
 }
 
-type OpenAISBUsageResponse struct {
-	Msg  string `json:"msg"`
-	Data *struct {
-		Credit string `json:"credit"`
-	} `json:"data"`
-}
-
-type AIProxyUserOverviewResponse struct {
-	Success   bool   `json:"success"`
-	Message   string `json:"message"`
-	ErrorCode int    `json:"error_code"`
-	Data      struct {
-		TotalPoints float64 `json:"totalPoints"`
-	} `json:"data"`
-}
-
-type API2GPTUsageResponse struct {
-	Object         string  `json:"object"`
-	TotalGranted   float64 `json:"total_granted"`
-	TotalUsed      float64 `json:"total_used"`
-	TotalRemaining float64 `json:"total_remaining"`
-}
-
-type APGC2DGPTUsageResponse struct {
-	//Grants         interface{} `json:"grants"`
-	Object         string  `json:"object"`
-	TotalAvailable float64 `json:"total_available"`
-	TotalGranted   float64 `json:"total_granted"`
-	TotalUsed      float64 `json:"total_used"`
-}
-
-// GetAuthHeader get auth header
-func GetAuthHeader(token string) http.Header {
-	h := http.Header{}
-	h.Add("Authorization", fmt.Sprintf("Bearer %s", token))
-	return h
-}
-
-func GetResponseBody(method, url string, channel *model.Channel, headers http.Header) ([]byte, error) {
-	req, err := http.NewRequest(method, url, nil)
-	if err != nil {
-		return nil, err
-	}
-	for k := range headers {
-		req.Header.Add(k, headers.Get(k))
-	}
-	res, err := httpClient.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	if res.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("status code: %d", res.StatusCode)
-	}
-	body, err := io.ReadAll(res.Body)
-	if err != nil {
-		return nil, err
-	}
-	err = res.Body.Close()
-	if err != nil {
-		return nil, err
-	}
-	return body, nil
-}
-
-func updateChannelCloseAIBalance(channel *model.Channel) (float64, error) {
-	url := fmt.Sprintf("%s/dashboard/billing/credit_grants", channel.GetBaseURL())
-	body, err := GetResponseBody("GET", url, channel, GetAuthHeader(channel.Key))
-
-	if err != nil {
-		return 0, err
-	}
-	response := OpenAICreditGrants{}
-	err = json.Unmarshal(body, &response)
-	if err != nil {
-		return 0, err
-	}
-	channel.UpdateBalance(response.TotalAvailable)
-	return response.TotalAvailable, nil
-}
-
-func updateChannelOpenAISBBalance(channel *model.Channel) (float64, error) {
-	url := fmt.Sprintf("https://api.openai-sb.com/sb-api/user/status?api_key=%s", channel.Key)
-	body, err := GetResponseBody("GET", url, channel, GetAuthHeader(channel.Key))
-	if err != nil {
-		return 0, err
-	}
-	response := OpenAISBUsageResponse{}
-	err = json.Unmarshal(body, &response)
-	if err != nil {
-		return 0, err
-	}
-	if response.Data == nil {
-		return 0, errors.New(response.Msg)
-	}
-	balance, err := strconv.ParseFloat(response.Data.Credit, 64)
-	if err != nil {
-		return 0, err
-	}
-	channel.UpdateBalance(balance)
-	return balance, nil
-}
-
-func updateChannelAIProxyBalance(channel *model.Channel) (float64, error) {
-	url := "https://aiproxy.io/api/report/getUserOverview"
-	headers := http.Header{}
-	headers.Add("Api-Key", channel.Key)
-	body, err := GetResponseBody("GET", url, channel, headers)
-	if err != nil {
-		return 0, err
-	}
-	response := AIProxyUserOverviewResponse{}
-	err = json.Unmarshal(body, &response)
-	if err != nil {
-		return 0, err
-	}
-	if !response.Success {
-		return 0, fmt.Errorf("code: %d, message: %s", response.ErrorCode, response.Message)
-	}
-	channel.UpdateBalance(response.Data.TotalPoints)
-	return response.Data.TotalPoints, nil
-}
-
-func updateChannelAPI2GPTBalance(channel *model.Channel) (float64, error) {
-	url := "https://api.api2gpt.com/dashboard/billing/credit_grants"
-	body, err := GetResponseBody("GET", url, channel, GetAuthHeader(channel.Key))
-
-	if err != nil {
-		return 0, err
-	}
-	response := API2GPTUsageResponse{}
-	err = json.Unmarshal(body, &response)
-	if err != nil {
-		return 0, err
-	}
-	channel.UpdateBalance(response.TotalRemaining)
-	return response.TotalRemaining, 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))
-	if err != nil {
-		return 0, err
-	}
-	response := APGC2DGPTUsageResponse{}
-	err = json.Unmarshal(body, &response)
-	if err != nil {
-		return 0, err
-	}
-	channel.UpdateBalance(response.TotalAvailable)
-	return response.TotalAvailable, nil
-}
-
 func updateChannelBalance(channel *model.Channel) (float64, error) {
-	baseURL := common.ChannelBaseURLs[channel.Type]
-	if channel.GetBaseURL() == "" {
-		channel.BaseURL = &baseURL
+	req, err := http.NewRequest("POST", "/balance", nil)
+	if err != nil {
+		return 0, err
 	}
-	switch channel.Type {
-	case common.ChannelTypeOpenAI:
-		if channel.GetBaseURL() != "" {
-			baseURL = channel.GetBaseURL()
-		}
-	case common.ChannelTypeAzure:
-		return 0, errors.New("尚未实现")
-	case common.ChannelTypeCustom:
-		baseURL = channel.GetBaseURL()
-	case common.ChannelTypeCloseAI:
-		return updateChannelCloseAIBalance(channel)
-	case common.ChannelTypeOpenAISB:
-		return updateChannelOpenAISBBalance(channel)
-	case common.ChannelTypeAIProxy:
-		return updateChannelAIProxyBalance(channel)
-	case common.ChannelTypeAPI2GPT:
-		return updateChannelAPI2GPTBalance(channel)
-	case common.ChannelTypeAIGC2D:
-		return updateChannelAIGC2DBalance(channel)
-	default:
-		return 0, errors.New("尚未实现")
-	}
-	url := fmt.Sprintf("%s/v1/dashboard/billing/subscription", baseURL)
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Request = req
 
-	body, err := GetResponseBody("GET", url, channel, GetAuthHeader(channel.Key))
-	if err != nil {
-		return 0, err
+	req.Header.Set("Content-Type", "application/json")
+
+	provider := providers.GetProvider(channel, c)
+	if provider == nil {
+		return 0, errors.New("provider not found")
 	}
-	subscription := OpenAISubscriptionResponse{}
-	err = json.Unmarshal(body, &subscription)
-	if err != nil {
-		return 0, err
+
+	balanceProvider, ok := provider.(providersBase.BalanceInterface)
+	if !ok {
+		return 0, errors.New("provider not implemented")
 	}
-	now := time.Now()
-	startDate := fmt.Sprintf("%s-01", now.Format("2006-01"))
-	endDate := now.Format("2006-01-02")
-	if !subscription.HasPaymentMethod {
-		startDate = now.AddDate(0, 0, -100).Format("2006-01-02")
-	}
-	url = fmt.Sprintf("%s/v1/dashboard/billing/usage?start_date=%s&end_date=%s", baseURL, startDate, endDate)
-	body, err = GetResponseBody("GET", url, channel, GetAuthHeader(channel.Key))
-	if err != nil {
-		return 0, err
-	}
-	usage := OpenAIUsageResponse{}
-	err = json.Unmarshal(body, &usage)
-	if err != nil {
-		return 0, err
-	}
-	balance := subscription.HardLimitUSD - usage.TotalUsage/100
-	channel.UpdateBalance(balance)
-	return balance, nil
+
+	return balanceProvider.Balance(channel)
+
 }
 
 func UpdateChannelBalance(c *gin.Context) {
@@ -288,7 +101,6 @@ func UpdateChannelBalance(c *gin.Context) {
 		"message": "",
 		"balance": balance,
 	})
-	return
 }
 
 func updateAllChannelsBalance() error {
@@ -332,7 +144,6 @@ func UpdateAllChannelsBalance(c *gin.Context) {
 		"success": true,
 		"message": "",
 	})
-	return
 }
 
 func AutomaticallyUpdateChannels(frequency int) {

controller/channel-test.go

@@ -1,14 +1,15 @@
 package controller
 
 import (
-	"bytes"
-	"encoding/json"
 	"errors"
 	"fmt"
-	"io"
 	"net/http"
+	"net/http/httptest"
 	"one-api/common"
 	"one-api/model"
+	"one-api/providers"
+	providers_base "one-api/providers/base"
+	"one-api/types"
 	"strconv"
 	"sync"
 	"time"
@@ -16,91 +17,80 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-func testChannel(channel *model.Channel, request ChatRequest) (err error, openaiErr *OpenAIError) {
-	switch channel.Type {
-	case common.ChannelTypePaLM:
-		fallthrough
-	case common.ChannelTypeGemini:
-		fallthrough
-	case common.ChannelTypeAnthropic:
-		fallthrough
-	case common.ChannelTypeBaidu:
-		fallthrough
-	case common.ChannelTypeZhipu:
-		fallthrough
-	case common.ChannelTypeAli:
-		fallthrough
-	case common.ChannelType360:
-		fallthrough
-	case common.ChannelTypeXunfei:
-		return errors.New("该渠道类型当前版本不支持测试，请手动测试"), nil
-	case common.ChannelTypeAzure:
-		request.Model = "gpt-35-turbo"
-		defer func() {
-			if err != nil {
-				err = errors.New("请确保已在 Azure 上创建了 gpt-35-turbo 模型，并且 apiVersion 已正确填写！")
-			}
-		}()
-	default:
-		request.Model = "gpt-3.5-turbo"
-	}
-	requestURL := common.ChannelBaseURLs[channel.Type]
-	if channel.Type == common.ChannelTypeAzure {
-		requestURL = getFullRequestURL(channel.GetBaseURL(), fmt.Sprintf("/openai/deployments/%s/chat/completions?api-version=2023-03-15-preview", request.Model), channel.Type)
-	} else {
-		if baseURL := channel.GetBaseURL(); len(baseURL) > 0 {
-			requestURL = baseURL
-		}
-
-		requestURL = getFullRequestURL(requestURL, "/v1/chat/completions", channel.Type)
-	}
-	jsonData, err := json.Marshal(request)
+func testChannel(channel *model.Channel, request types.ChatCompletionRequest) (err error, openaiErr *types.OpenAIError) {
+	// 创建一个 http.Request
+	req, err := http.NewRequest("POST", "/v1/chat/completions", nil)
 	if err != nil {
 		return err, nil
 	}
-	req, err := http.NewRequest("POST", requestURL, bytes.NewBuffer(jsonData))
-	if err != nil {
-		return err, nil
-	}
-	if channel.Type == common.ChannelTypeAzure {
-		req.Header.Set("api-key", channel.Key)
-	} else {
-		req.Header.Set("Authorization", "Bearer "+channel.Key)
-	}
 	req.Header.Set("Content-Type", "application/json")
-	resp, err := httpClient.Do(req)
+
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Request = req
+
+	// 创建映射
+	channelTypeToModel := map[int]string{
+		common.ChannelTypePaLM:      "PaLM-2",
+		common.ChannelTypeAnthropic: "claude-2",
+		common.ChannelTypeBaidu:     "ERNIE-Bot",
+		common.ChannelTypeZhipu:     "chatglm_lite",
+		common.ChannelTypeAli:       "qwen-turbo",
+		common.ChannelType360:       "360GPT_S2_V9",
+		common.ChannelTypeXunfei:    "SparkDesk",
+		common.ChannelTypeTencent:   "hunyuan",
+		common.ChannelTypeAzure:     "gpt-3.5-turbo",
+	}
+
+	// 从映射中获取模型名称
+	model, ok := channelTypeToModel[channel.Type]
+	if !ok {
+		model = "gpt-3.5-turbo" // 默认值
+	}
+	request.Model = model
+
+	provider := providers.GetProvider(channel, c)
+	if provider == nil {
+		return errors.New("channel not implemented"), nil
+	}
+	chatProvider, ok := provider.(providers_base.ChatInterface)
+	if !ok {
+		return errors.New("channel not implemented"), nil
+	}
+
+	modelMap, err := parseModelMapping(channel.GetModelMapping())
 	if err != nil {
 		return err, nil
 	}
-	defer resp.Body.Close()
-	var response TextResponse
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return err, nil
+	if modelMap != nil && modelMap[request.Model] != "" {
+		request.Model = modelMap[request.Model]
 	}
-	err = json.Unmarshal(body, &response)
-	if err != nil {
-		return fmt.Errorf("Error: %s\nResp body: %s", err, body), nil
+
+	promptTokens := common.CountTokenMessages(request.Messages, request.Model)
+	Usage, openAIErrorWithStatusCode := chatProvider.ChatAction(&request, true, promptTokens)
+	if openAIErrorWithStatusCode != nil {
+		return nil, &openAIErrorWithStatusCode.OpenAIError
 	}
-	if response.Usage.CompletionTokens == 0 {
-		if response.Error.Message == "" {
-			response.Error.Message = "补全 tokens 非预期返回 0"
-		}
-		return errors.New(fmt.Sprintf("type %s, code %v, message %s", response.Error.Type, response.Error.Code, response.Error.Message)), &response.Error
+
+	if Usage.CompletionTokens == 0 {
+		return fmt.Errorf("channel %s, message 补全 tokens 非预期返回 0", channel.Name), nil
 	}
+
 	return nil, nil
 }
 
-func buildTestRequest() *ChatRequest {
-	testRequest := &ChatRequest{
-		Model:     "", // this will be set later
+func buildTestRequest() *types.ChatCompletionRequest {
+	testRequest := &types.ChatCompletionRequest{
+		Messages: []types.ChatCompletionMessage{
+			{
+				Role:    "user",
+				Content: "You just need to output 'hi' next.",
+			},
+		},
+		Model:     "",
 		MaxTokens: 1,
+		Stream:    false,
 	}
-	testMessage := Message{
-		Role:    "user",
-		Content: "hi",
-	}
-	testRequest.Messages = append(testRequest.Messages, testMessage)
 	return testRequest
 }
 
@@ -141,7 +131,6 @@ func TestChannel(c *gin.Context) {
 		"message": "",
 		"time":    consumedTime,
 	})
-	return
 }
 
 var testAllChannelsLock sync.Mutex
@@ -200,8 +189,8 @@ func testAllChannels(notify bool) error {
 			err, openaiErr := testChannel(channel, *testRequest)
 			tok := time.Now()
 			milliseconds := tok.Sub(tik).Milliseconds()
-			if isChannelEnabled && milliseconds > disableThreshold {
-				err = errors.New(fmt.Sprintf("响应时间 %.2fs 超过阈值 %.2fs", float64(milliseconds)/1000.0, float64(disableThreshold)/1000.0))
+			if milliseconds > disableThreshold {
+				err = fmt.Errorf("响应时间 %.2fs 超过阈值 %.2fs", float64(milliseconds)/1000.0, float64(disableThreshold)/1000.0)
 				disableChannel(channel.Id, channel.Name, err.Error())
 			}
 			if isChannelEnabled && shouldDisableChannel(openaiErr, -1) {
@@ -239,7 +228,6 @@ func TestAllChannels(c *gin.Context) {
 		"success": true,
 		"message": "",
 	})
-	return
 }
 
 func AutomaticallyTestChannels(frequency int) {

controller/channel.go

@@ -1,12 +1,13 @@
 package controller
 
 import (
-	"github.com/gin-gonic/gin"
 	"net/http"
 	"one-api/common"
 	"one-api/model"
 	"strconv"
 	"strings"
+
+	"github.com/gin-gonic/gin"
 )
 
 func GetAllChannels(c *gin.Context) {
@@ -27,7 +28,6 @@ func GetAllChannels(c *gin.Context) {
 		"message": "",
 		"data":    channels,
 	})
-	return
 }
 
 func SearchChannels(c *gin.Context) {
@@ -45,7 +45,6 @@ func SearchChannels(c *gin.Context) {
 		"message": "",
 		"data":    channels,
 	})
-	return
 }
 
 func GetChannel(c *gin.Context) {
@@ -70,7 +69,6 @@ func GetChannel(c *gin.Context) {
 		"message": "",
 		"data":    channel,
 	})
-	return
 }
 
 func AddChannel(c *gin.Context) {
@@ -106,7 +104,6 @@ func AddChannel(c *gin.Context) {
 		"success": true,
 		"message": "",
 	})
-	return
 }
 
 func DeleteChannel(c *gin.Context) {
@@ -124,7 +121,6 @@ func DeleteChannel(c *gin.Context) {
 		"success": true,
 		"message": "",
 	})
-	return
 }
 
 func DeleteDisabledChannel(c *gin.Context) {
@@ -141,7 +137,6 @@ func DeleteDisabledChannel(c *gin.Context) {
 		"message": "",
 		"data":    rows,
 	})
-	return
 }
 
 func UpdateChannel(c *gin.Context) {
@@ -167,5 +162,4 @@ func UpdateChannel(c *gin.Context) {
 		"message": "",
 		"data":    channel,
 	})
-	return
 }

controller/github.go

@@ -5,13 +5,14 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/gin-contrib/sessions"
-	"github.com/gin-gonic/gin"
 	"net/http"
 	"one-api/common"
 	"one-api/model"
 	"strconv"
 	"time"
+
+	"github.com/gin-contrib/sessions"
+	"github.com/gin-gonic/gin"
 )
 
 type GitHubOAuthResponse struct {
@@ -211,7 +212,6 @@ func GitHubBind(c *gin.Context) {
 		"success": true,
 		"message": "bind",
 	})
-	return
 }
 
 func GenerateOAuthCode(c *gin.Context) {

controller/group.go

@@ -1,14 +1,15 @@
 package controller
 
 import (
-	"github.com/gin-gonic/gin"
 	"net/http"
 	"one-api/common"
+
+	"github.com/gin-gonic/gin"
 )
 
 func GetGroups(c *gin.Context) {
 	groupNames := make([]string, 0)
-	for groupName, _ := range common.GroupRatio {
+	for groupName := range common.GroupRatio {
 		groupNames = append(groupNames, groupName)
 	}
 	c.JSON(http.StatusOK, gin.H{

controller/log.go

@@ -1,11 +1,12 @@
 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) {
@@ -33,7 +34,6 @@ func GetAllLogs(c *gin.Context) {
 		"message": "",
 		"data":    logs,
 	})
-	return
 }
 
 func GetUserLogs(c *gin.Context) {
@@ -60,7 +60,6 @@ func GetUserLogs(c *gin.Context) {
 		"message": "",
 		"data":    logs,
 	})
-	return
 }
 
 func SearchAllLogs(c *gin.Context) {
@@ -78,7 +77,6 @@ func SearchAllLogs(c *gin.Context) {
 		"message": "",
 		"data":    logs,
 	})
-	return
 }
 
 func SearchUserLogs(c *gin.Context) {
@@ -97,7 +95,6 @@ func SearchUserLogs(c *gin.Context) {
 		"message": "",
 		"data":    logs,
 	})
-	return
 }
 
 func GetLogsStat(c *gin.Context) {
@@ -118,7 +115,6 @@ func GetLogsStat(c *gin.Context) {
 			//"token": tokenNum,
 		},
 	})
-	return
 }
 
 func GetLogsSelfStat(c *gin.Context) {
@@ -139,7 +135,6 @@ func GetLogsSelfStat(c *gin.Context) {
 			//"token": tokenNum,
 		},
 	})
-	return
 }
 
 func DeleteHistoryLogs(c *gin.Context) {
@@ -164,5 +159,4 @@ func DeleteHistoryLogs(c *gin.Context) {
 		"message": "",
 		"data":    count,
 	})
-	return
 }

controller/misc.go

@@ -35,7 +35,6 @@ func GetStatus(c *gin.Context) {
 			"display_in_currency": common.DisplayInCurrencyEnabled,
 		},
 	})
-	return
 }
 
 func GetNotice(c *gin.Context) {
@@ -46,7 +45,6 @@ func GetNotice(c *gin.Context) {
 		"message": "",
 		"data":    common.OptionMap["Notice"],
 	})
-	return
 }
 
 func GetAbout(c *gin.Context) {
@@ -57,7 +55,6 @@ func GetAbout(c *gin.Context) {
 		"message": "",
 		"data":    common.OptionMap["About"],
 	})
-	return
 }
 
 func GetHomePageContent(c *gin.Context) {
@@ -68,7 +65,6 @@ func GetHomePageContent(c *gin.Context) {
 		"message": "",
 		"data":    common.OptionMap["HomePageContent"],
 	})
-	return
 }
 
 func SendEmailVerification(c *gin.Context) {
@@ -121,7 +117,6 @@ func SendEmailVerification(c *gin.Context) {
 		"success": true,
 		"message": "",
 	})
-	return
 }
 
 func SendPasswordResetEmail(c *gin.Context) {
@@ -160,7 +155,6 @@ func SendPasswordResetEmail(c *gin.Context) {
 		"success": true,
 		"message": "",
 	})
-	return
 }
 
 type PasswordResetRequest struct {
@@ -200,5 +194,4 @@ func ResetPassword(c *gin.Context) {
 		"message": "",
 		"data":    password,
 	})
-	return
 }

controller/model.go

@@ -2,6 +2,7 @@ package controller
 
 import (
 	"fmt"
+	"one-api/types"
 
 	"github.com/gin-gonic/gin"
 )
@@ -595,7 +596,7 @@ func RetrieveModel(c *gin.Context) {
 	if model, ok := openAIModelsMap[modelId]; ok {
 		c.JSON(200, model)
 	} else {
-		openAIError := OpenAIError{
+		openAIError := types.OpenAIError{
 			Message: fmt.Sprintf("The model '%s' does not exist", modelId),
 			Type:    "invalid_request_error",
 			Param:   "model",

controller/relay-aiproxy.go

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

controller/relay-ali.go

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

controller/relay-audio.go

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

controller/relay-baidu.go

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

controller/relay-chat.go

@@ -0,0 +1,94 @@
+package controller
+
+import (
+	"context"
+	"math"
+	"net/http"
+	"one-api/common"
+	"one-api/model"
+	providersBase "one-api/providers/base"
+	"one-api/types"
+
+	"github.com/gin-gonic/gin"
+)
+
+func RelayChat(c *gin.Context) {
+
+	var chatRequest types.ChatCompletionRequest
+	if err := common.UnmarshalBodyReusable(c, &chatRequest); err != nil {
+		common.AbortWithMessage(c, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	channel, pass := fetchChannel(c, chatRequest.Model)
+	if pass {
+		return
+	}
+
+	if chatRequest.MaxTokens < 0 || chatRequest.MaxTokens > math.MaxInt32/2 {
+		common.AbortWithMessage(c, http.StatusBadRequest, "max_tokens is invalid")
+		return
+	}
+
+	// 解析模型映射
+	var isModelMapped bool
+	modelMap, err := parseModelMapping(channel.GetModelMapping())
+	if err != nil {
+		common.AbortWithMessage(c, http.StatusInternalServerError, err.Error())
+		return
+	}
+	if modelMap != nil && modelMap[chatRequest.Model] != "" {
+		chatRequest.Model = modelMap[chatRequest.Model]
+		isModelMapped = true
+	}
+
+	// 获取供应商
+	provider, pass := getProvider(c, channel, common.RelayModeChatCompletions)
+	if pass {
+		return
+	}
+	chatProvider, ok := provider.(providersBase.ChatInterface)
+	if !ok {
+		common.AbortWithMessage(c, http.StatusNotImplemented, "channel not implemented")
+		return
+	}
+
+	// 获取Input Tokens
+	promptTokens := common.CountTokenMessages(chatRequest.Messages, chatRequest.Model)
+
+	var quotaInfo *QuotaInfo
+	var errWithCode *types.OpenAIErrorWithStatusCode
+	var usage *types.Usage
+	quotaInfo, errWithCode = generateQuotaInfo(c, chatRequest.Model, promptTokens)
+	if errWithCode != nil {
+		errorHelper(c, errWithCode)
+		return
+	}
+
+	usage, errWithCode = chatProvider.ChatAction(&chatRequest, isModelMapped, promptTokens)
+
+	// 如果报错，则退还配额
+	if errWithCode != nil {
+		tokenId := c.GetInt("token_id")
+		if quotaInfo.HandelStatus {
+			go func(ctx context.Context) {
+				// return pre-consumed quota
+				err := model.PostConsumeTokenQuota(tokenId, -quotaInfo.preConsumedQuota)
+				if err != nil {
+					common.LogError(ctx, "error return pre-consumed quota: "+err.Error())
+				}
+			}(c.Request.Context())
+		}
+		errorHelper(c, errWithCode)
+		return
+	} else {
+		tokenName := c.GetString("token_name")
+		// 如果没有报错，则消费配额
+		go func(ctx context.Context) {
+			err = quotaInfo.completedQuotaConsumption(usage, tokenName, ctx)
+			if err != nil {
+				common.LogError(ctx, err.Error())
+			}
+		}(c.Request.Context())
+	}
+}

controller/relay-claude.go

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

controller/relay-completions.go

@@ -0,0 +1,94 @@
+package controller
+
+import (
+	"context"
+	"math"
+	"net/http"
+	"one-api/common"
+	"one-api/model"
+	providersBase "one-api/providers/base"
+	"one-api/types"
+
+	"github.com/gin-gonic/gin"
+)
+
+func RelayCompletions(c *gin.Context) {
+
+	var completionRequest types.CompletionRequest
+	if err := common.UnmarshalBodyReusable(c, &completionRequest); err != nil {
+		common.AbortWithMessage(c, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	channel, pass := fetchChannel(c, completionRequest.Model)
+	if pass {
+		return
+	}
+
+	if completionRequest.MaxTokens < 0 || completionRequest.MaxTokens > math.MaxInt32/2 {
+		common.AbortWithMessage(c, http.StatusBadRequest, "max_tokens is invalid")
+		return
+	}
+
+	// 解析模型映射
+	var isModelMapped bool
+	modelMap, err := parseModelMapping(channel.GetModelMapping())
+	if err != nil {
+		common.AbortWithMessage(c, http.StatusInternalServerError, err.Error())
+		return
+	}
+	if modelMap != nil && modelMap[completionRequest.Model] != "" {
+		completionRequest.Model = modelMap[completionRequest.Model]
+		isModelMapped = true
+	}
+
+	// 获取供应商
+	provider, pass := getProvider(c, channel, common.RelayModeCompletions)
+	if pass {
+		return
+	}
+	completionProvider, ok := provider.(providersBase.CompletionInterface)
+	if !ok {
+		common.AbortWithMessage(c, http.StatusNotImplemented, "channel not implemented")
+		return
+	}
+
+	// 获取Input Tokens
+	promptTokens := common.CountTokenInput(completionRequest.Prompt, completionRequest.Model)
+
+	var quotaInfo *QuotaInfo
+	var errWithCode *types.OpenAIErrorWithStatusCode
+	var usage *types.Usage
+	quotaInfo, errWithCode = generateQuotaInfo(c, completionRequest.Model, promptTokens)
+	if errWithCode != nil {
+		errorHelper(c, errWithCode)
+		return
+	}
+
+	usage, errWithCode = completionProvider.CompleteAction(&completionRequest, isModelMapped, promptTokens)
+
+	// 如果报错，则退还配额
+	if errWithCode != nil {
+		tokenId := c.GetInt("token_id")
+		if quotaInfo.HandelStatus {
+			go func(ctx context.Context) {
+				// return pre-consumed quota
+				err := model.PostConsumeTokenQuota(tokenId, -quotaInfo.preConsumedQuota)
+				if err != nil {
+					common.LogError(ctx, "error return pre-consumed quota: "+err.Error())
+				}
+			}(c.Request.Context())
+		}
+		errorHelper(c, errWithCode)
+		return
+	} else {
+		tokenName := c.GetString("token_name")
+		// 如果没有报错，则消费配额
+		go func(ctx context.Context) {
+			err = quotaInfo.completedQuotaConsumption(usage, tokenName, ctx)
+			if err != nil {
+				common.LogError(ctx, err.Error())
+			}
+		}(c.Request.Context())
+	}
+}

controller/relay-embeddings.go

@@ -0,0 +1,93 @@
+package controller
+
+import (
+	"context"
+	"net/http"
+	"one-api/common"
+	"one-api/model"
+	providersBase "one-api/providers/base"
+	"one-api/types"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+)
+
+func RelayEmbeddings(c *gin.Context) {
+
+	var embeddingsRequest types.EmbeddingRequest
+	if strings.HasSuffix(c.Request.URL.Path, "embeddings") {
+		embeddingsRequest.Model = c.Param("model")
+	}
+
+	if err := common.UnmarshalBodyReusable(c, &embeddingsRequest); err != nil {
+		common.AbortWithMessage(c, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	channel, pass := fetchChannel(c, embeddingsRequest.Model)
+	if pass {
+		return
+	}
+
+	// 解析模型映射
+	var isModelMapped bool
+	modelMap, err := parseModelMapping(channel.GetModelMapping())
+	if err != nil {
+		common.AbortWithMessage(c, http.StatusInternalServerError, err.Error())
+		return
+	}
+	if modelMap != nil && modelMap[embeddingsRequest.Model] != "" {
+		embeddingsRequest.Model = modelMap[embeddingsRequest.Model]
+		isModelMapped = true
+	}
+
+	// 获取供应商
+	provider, pass := getProvider(c, channel, common.RelayModeEmbeddings)
+	if pass {
+		return
+	}
+	embeddingsProvider, ok := provider.(providersBase.EmbeddingsInterface)
+	if !ok {
+		common.AbortWithMessage(c, http.StatusNotImplemented, "channel not implemented")
+		return
+	}
+
+	// 获取Input Tokens
+	promptTokens := common.CountTokenInput(embeddingsRequest.Input, embeddingsRequest.Model)
+
+	var quotaInfo *QuotaInfo
+	var errWithCode *types.OpenAIErrorWithStatusCode
+	var usage *types.Usage
+	quotaInfo, errWithCode = generateQuotaInfo(c, embeddingsRequest.Model, promptTokens)
+	if errWithCode != nil {
+		errorHelper(c, errWithCode)
+		return
+	}
+
+	usage, errWithCode = embeddingsProvider.EmbeddingsAction(&embeddingsRequest, isModelMapped, promptTokens)
+
+	// 如果报错，则退还配额
+	if errWithCode != nil {
+		tokenId := c.GetInt("token_id")
+		if quotaInfo.HandelStatus {
+			go func(ctx context.Context) {
+				// return pre-consumed quota
+				err := model.PostConsumeTokenQuota(tokenId, -quotaInfo.preConsumedQuota)
+				if err != nil {
+					common.LogError(ctx, "error return pre-consumed quota: "+err.Error())
+				}
+			}(c.Request.Context())
+		}
+		errorHelper(c, errWithCode)
+		return
+	} else {
+		tokenName := c.GetString("token_name")
+		// 如果没有报错，则消费配额
+		go func(ctx context.Context) {
+			err = quotaInfo.completedQuotaConsumption(usage, tokenName, ctx)
+			if err != nil {
+				common.LogError(ctx, err.Error())
+			}
+		}(c.Request.Context())
+	}
+}

controller/relay-gemini.go

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

controller/relay-image-edits.go

@@ -0,0 +1,106 @@
+package controller
+
+import (
+	"context"
+	"net/http"
+	"one-api/common"
+	"one-api/model"
+	providersBase "one-api/providers/base"
+	"one-api/types"
+
+	"github.com/gin-gonic/gin"
+)
+
+func RelayImageEdits(c *gin.Context) {
+
+	var imageEditRequest types.ImageEditRequest
+
+	if err := common.UnmarshalBodyReusable(c, &imageEditRequest); err != nil {
+		common.AbortWithMessage(c, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	if imageEditRequest.Prompt == "" {
+		common.AbortWithMessage(c, http.StatusBadRequest, "field prompt is required")
+		return
+	}
+
+	if imageEditRequest.Model == "" {
+		imageEditRequest.Model = "dall-e-2"
+	}
+
+	if imageEditRequest.Size == "" {
+		imageEditRequest.Size = "1024x1024"
+	}
+
+	channel, pass := fetchChannel(c, imageEditRequest.Model)
+	if pass {
+		return
+	}
+
+	// 解析模型映射
+	var isModelMapped bool
+	modelMap, err := parseModelMapping(channel.GetModelMapping())
+	if err != nil {
+		common.AbortWithMessage(c, http.StatusInternalServerError, err.Error())
+		return
+	}
+	if modelMap != nil && modelMap[imageEditRequest.Model] != "" {
+		imageEditRequest.Model = modelMap[imageEditRequest.Model]
+		isModelMapped = true
+	}
+
+	// 获取供应商
+	provider, pass := getProvider(c, channel, common.RelayModeImagesEdits)
+	if pass {
+		return
+	}
+	imageEditsProvider, ok := provider.(providersBase.ImageEditsInterface)
+	if !ok {
+		common.AbortWithMessage(c, http.StatusNotImplemented, "channel not implemented")
+		return
+	}
+
+	// 获取Input Tokens
+	promptTokens, err := common.CountTokenImage(imageEditRequest)
+	if err != nil {
+		common.AbortWithMessage(c, http.StatusInternalServerError, err.Error())
+		return
+	}
+
+	var quotaInfo *QuotaInfo
+	var errWithCode *types.OpenAIErrorWithStatusCode
+	var usage *types.Usage
+	quotaInfo, errWithCode = generateQuotaInfo(c, imageEditRequest.Model, promptTokens)
+	if errWithCode != nil {
+		errorHelper(c, errWithCode)
+		return
+	}
+
+	usage, errWithCode = imageEditsProvider.ImageEditsAction(&imageEditRequest, isModelMapped, promptTokens)
+
+	// 如果报错，则退还配额
+	if errWithCode != nil {
+		tokenId := c.GetInt("token_id")
+		if quotaInfo.HandelStatus {
+			go func(ctx context.Context) {
+				// return pre-consumed quota
+				err := model.PostConsumeTokenQuota(tokenId, -quotaInfo.preConsumedQuota)
+				if err != nil {
+					common.LogError(ctx, "error return pre-consumed quota: "+err.Error())
+				}
+			}(c.Request.Context())
+		}
+		errorHelper(c, errWithCode)
+		return
+	} else {
+		tokenName := c.GetString("token_name")
+		// 如果没有报错，则消费配额
+		go func(ctx context.Context) {
+			err = quotaInfo.completedQuotaConsumption(usage, tokenName, ctx)
+			if err != nil {
+				common.LogError(ctx, err.Error())
+			}
+		}(c.Request.Context())
+	}
+}

controller/relay-image-generations.go

@@ -0,0 +1,109 @@
+package controller
+
+import (
+	"context"
+	"net/http"
+	"one-api/common"
+	"one-api/model"
+	providersBase "one-api/providers/base"
+	"one-api/types"
+
+	"github.com/gin-gonic/gin"
+)
+
+func RelayImageGenerations(c *gin.Context) {
+
+	var imageRequest types.ImageRequest
+
+	if err := common.UnmarshalBodyReusable(c, &imageRequest); err != nil {
+		common.AbortWithMessage(c, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	if imageRequest.Model == "" {
+		imageRequest.Model = "dall-e-2"
+	}
+
+	if imageRequest.N == 0 {
+		imageRequest.N = 1
+	}
+
+	if imageRequest.Size == "" {
+		imageRequest.Size = "1024x1024"
+	}
+
+	if imageRequest.Quality == "" {
+		imageRequest.Quality = "standard"
+	}
+
+	channel, pass := fetchChannel(c, imageRequest.Model)
+	if pass {
+		return
+	}
+
+	// 解析模型映射
+	var isModelMapped bool
+	modelMap, err := parseModelMapping(channel.GetModelMapping())
+	if err != nil {
+		common.AbortWithMessage(c, http.StatusInternalServerError, err.Error())
+		return
+	}
+	if modelMap != nil && modelMap[imageRequest.Model] != "" {
+		imageRequest.Model = modelMap[imageRequest.Model]
+		isModelMapped = true
+	}
+
+	// 获取供应商
+	provider, pass := getProvider(c, channel, common.RelayModeImagesGenerations)
+	if pass {
+		return
+	}
+	imageGenerationsProvider, ok := provider.(providersBase.ImageGenerationsInterface)
+	if !ok {
+		common.AbortWithMessage(c, http.StatusNotImplemented, "channel not implemented")
+		return
+	}
+
+	// 获取Input Tokens
+	promptTokens, err := common.CountTokenImage(imageRequest)
+	if err != nil {
+		common.AbortWithMessage(c, http.StatusInternalServerError, err.Error())
+		return
+	}
+
+	var quotaInfo *QuotaInfo
+	var errWithCode *types.OpenAIErrorWithStatusCode
+	var usage *types.Usage
+	quotaInfo, errWithCode = generateQuotaInfo(c, imageRequest.Model, promptTokens)
+	if errWithCode != nil {
+		errorHelper(c, errWithCode)
+		return
+	}
+
+	usage, errWithCode = imageGenerationsProvider.ImageGenerationsAction(&imageRequest, isModelMapped, promptTokens)
+
+	// 如果报错，则退还配额
+	if errWithCode != nil {
+		tokenId := c.GetInt("token_id")
+		if quotaInfo.HandelStatus {
+			go func(ctx context.Context) {
+				// return pre-consumed quota
+				err := model.PostConsumeTokenQuota(tokenId, -quotaInfo.preConsumedQuota)
+				if err != nil {
+					common.LogError(ctx, "error return pre-consumed quota: "+err.Error())
+				}
+			}(c.Request.Context())
+		}
+		errorHelper(c, errWithCode)
+		return
+	} else {
+		tokenName := c.GetString("token_name")
+		// 如果没有报错，则消费配额
+		go func(ctx context.Context) {
+			err = quotaInfo.completedQuotaConsumption(usage, tokenName, ctx)
+			if err != nil {
+				common.LogError(ctx, err.Error())
+			}
+		}(c.Request.Context())
+	}
+}

controller/relay-image-variationsy.go

@@ -0,0 +1,101 @@
+package controller
+
+import (
+	"context"
+	"net/http"
+	"one-api/common"
+	"one-api/model"
+	providersBase "one-api/providers/base"
+	"one-api/types"
+
+	"github.com/gin-gonic/gin"
+)
+
+func RelayImageVariations(c *gin.Context) {
+
+	var imageEditRequest types.ImageEditRequest
+
+	if err := common.UnmarshalBodyReusable(c, &imageEditRequest); err != nil {
+		common.AbortWithMessage(c, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	if imageEditRequest.Model == "" {
+		imageEditRequest.Model = "dall-e-2"
+	}
+
+	if imageEditRequest.Size == "" {
+		imageEditRequest.Size = "1024x1024"
+	}
+
+	channel, pass := fetchChannel(c, imageEditRequest.Model)
+	if pass {
+		return
+	}
+
+	// 解析模型映射
+	var isModelMapped bool
+	modelMap, err := parseModelMapping(channel.GetModelMapping())
+	if err != nil {
+		common.AbortWithMessage(c, http.StatusInternalServerError, err.Error())
+		return
+	}
+	if modelMap != nil && modelMap[imageEditRequest.Model] != "" {
+		imageEditRequest.Model = modelMap[imageEditRequest.Model]
+		isModelMapped = true
+	}
+
+	// 获取供应商
+	provider, pass := getProvider(c, channel, common.RelayModeImagesVariations)
+	if pass {
+		return
+	}
+	imageVariations, ok := provider.(providersBase.ImageVariationsInterface)
+	if !ok {
+		common.AbortWithMessage(c, http.StatusNotImplemented, "channel not implemented")
+		return
+	}
+
+	// 获取Input Tokens
+	promptTokens, err := common.CountTokenImage(imageEditRequest)
+	if err != nil {
+		common.AbortWithMessage(c, http.StatusInternalServerError, err.Error())
+		return
+	}
+
+	var quotaInfo *QuotaInfo
+	var errWithCode *types.OpenAIErrorWithStatusCode
+	var usage *types.Usage
+	quotaInfo, errWithCode = generateQuotaInfo(c, imageEditRequest.Model, promptTokens)
+	if errWithCode != nil {
+		errorHelper(c, errWithCode)
+		return
+	}
+
+	usage, errWithCode = imageVariations.ImageVariationsAction(&imageEditRequest, isModelMapped, promptTokens)
+
+	// 如果报错，则退还配额
+	if errWithCode != nil {
+		tokenId := c.GetInt("token_id")
+		if quotaInfo.HandelStatus {
+			go func(ctx context.Context) {
+				// return pre-consumed quota
+				err := model.PostConsumeTokenQuota(tokenId, -quotaInfo.preConsumedQuota)
+				if err != nil {
+					common.LogError(ctx, "error return pre-consumed quota: "+err.Error())
+				}
+			}(c.Request.Context())
+		}
+		errorHelper(c, errWithCode)
+		return
+	} else {
+		tokenName := c.GetString("token_name")
+		// 如果没有报错，则消费配额
+		go func(ctx context.Context) {
+			err = quotaInfo.completedQuotaConsumption(usage, tokenName, ctx)
+			if err != nil {
+				common.LogError(ctx, err.Error())
+			}
+		}(c.Request.Context())
+	}
+}

controller/relay-image.go

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

controller/relay-moderations.go

@@ -0,0 +1,93 @@
+package controller
+
+import (
+	"context"
+	"net/http"
+	"one-api/common"
+	"one-api/model"
+	providersBase "one-api/providers/base"
+	"one-api/types"
+
+	"github.com/gin-gonic/gin"
+)
+
+func RelayModerations(c *gin.Context) {
+
+	var moderationRequest types.ModerationRequest
+
+	if err := common.UnmarshalBodyReusable(c, &moderationRequest); err != nil {
+		common.AbortWithMessage(c, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	if moderationRequest.Model == "" {
+		moderationRequest.Model = "text-moderation-stable"
+	}
+
+	channel, pass := fetchChannel(c, moderationRequest.Model)
+	if pass {
+		return
+	}
+
+	// 解析模型映射
+	var isModelMapped bool
+	modelMap, err := parseModelMapping(channel.GetModelMapping())
+	if err != nil {
+		common.AbortWithMessage(c, http.StatusInternalServerError, err.Error())
+		return
+	}
+	if modelMap != nil && modelMap[moderationRequest.Model] != "" {
+		moderationRequest.Model = modelMap[moderationRequest.Model]
+		isModelMapped = true
+	}
+
+	// 获取供应商
+	provider, pass := getProvider(c, channel, common.RelayModeModerations)
+	if pass {
+		return
+	}
+	moderationProvider, ok := provider.(providersBase.ModerationInterface)
+	if !ok {
+		common.AbortWithMessage(c, http.StatusNotImplemented, "channel not implemented")
+		return
+	}
+
+	// 获取Input Tokens
+	promptTokens := common.CountTokenInput(moderationRequest.Input, moderationRequest.Model)
+
+	var quotaInfo *QuotaInfo
+	var errWithCode *types.OpenAIErrorWithStatusCode
+	var usage *types.Usage
+	quotaInfo, errWithCode = generateQuotaInfo(c, moderationRequest.Model, promptTokens)
+	if errWithCode != nil {
+		errorHelper(c, errWithCode)
+		return
+	}
+
+	usage, errWithCode = moderationProvider.ModerationAction(&moderationRequest, isModelMapped, promptTokens)
+
+	// 如果报错，则退还配额
+	if errWithCode != nil {
+		tokenId := c.GetInt("token_id")
+		if quotaInfo.HandelStatus {
+			go func(ctx context.Context) {
+				// return pre-consumed quota
+				err := model.PostConsumeTokenQuota(tokenId, -quotaInfo.preConsumedQuota)
+				if err != nil {
+					common.LogError(ctx, "error return pre-consumed quota: "+err.Error())
+				}
+			}(c.Request.Context())
+		}
+		errorHelper(c, errWithCode)
+		return
+	} else {
+		tokenName := c.GetString("token_name")
+		// 如果没有报错，则消费配额
+		go func(ctx context.Context) {
+			err = quotaInfo.completedQuotaConsumption(usage, tokenName, ctx)
+			if err != nil {
+				common.LogError(ctx, err.Error())
+			}
+		}(c.Request.Context())
+	}
+}

controller/relay-openai.go

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

controller/relay-palm.go

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

controller/relay-speech.go

@@ -0,0 +1,89 @@
+package controller
+
+import (
+	"context"
+	"net/http"
+	"one-api/common"
+	"one-api/model"
+	providersBase "one-api/providers/base"
+	"one-api/types"
+
+	"github.com/gin-gonic/gin"
+)
+
+func RelaySpeech(c *gin.Context) {
+
+	var speechRequest types.SpeechAudioRequest
+
+	if err := common.UnmarshalBodyReusable(c, &speechRequest); err != nil {
+		common.AbortWithMessage(c, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	channel, pass := fetchChannel(c, speechRequest.Model)
+	if pass {
+		return
+	}
+
+	// 解析模型映射
+	var isModelMapped bool
+	modelMap, err := parseModelMapping(channel.GetModelMapping())
+	if err != nil {
+		common.AbortWithMessage(c, http.StatusInternalServerError, err.Error())
+		return
+	}
+	if modelMap != nil && modelMap[speechRequest.Model] != "" {
+		speechRequest.Model = modelMap[speechRequest.Model]
+		isModelMapped = true
+	}
+
+	// 获取供应商
+	provider, pass := getProvider(c, channel, common.RelayModeAudioSpeech)
+	if pass {
+		return
+	}
+	speechProvider, ok := provider.(providersBase.SpeechInterface)
+	if !ok {
+		common.AbortWithMessage(c, http.StatusNotImplemented, "channel not implemented")
+		return
+	}
+
+	// 获取Input Tokens
+	promptTokens := len(speechRequest.Input)
+
+	var quotaInfo *QuotaInfo
+	var errWithCode *types.OpenAIErrorWithStatusCode
+	var usage *types.Usage
+	quotaInfo, errWithCode = generateQuotaInfo(c, speechRequest.Model, promptTokens)
+	if errWithCode != nil {
+		errorHelper(c, errWithCode)
+		return
+	}
+
+	usage, errWithCode = speechProvider.SpeechAction(&speechRequest, isModelMapped, promptTokens)
+
+	// 如果报错，则退还配额
+	if errWithCode != nil {
+		tokenId := c.GetInt("token_id")
+		if quotaInfo.HandelStatus {
+			go func(ctx context.Context) {
+				// return pre-consumed quota
+				err := model.PostConsumeTokenQuota(tokenId, -quotaInfo.preConsumedQuota)
+				if err != nil {
+					common.LogError(ctx, "error return pre-consumed quota: "+err.Error())
+				}
+			}(c.Request.Context())
+		}
+		errorHelper(c, errWithCode)
+		return
+	} else {
+		tokenName := c.GetString("token_name")
+		// 如果没有报错，则消费配额
+		go func(ctx context.Context) {
+			err = quotaInfo.completedQuotaConsumption(usage, tokenName, ctx)
+			if err != nil {
+				common.LogError(ctx, err.Error())
+			}
+		}(c.Request.Context())
+	}
+}

controller/relay-tencent.go

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

controller/relay-text.go

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

controller/relay-transcriptions.go

@@ -0,0 +1,89 @@
+package controller
+
+import (
+	"context"
+	"net/http"
+	"one-api/common"
+	"one-api/model"
+	providersBase "one-api/providers/base"
+	"one-api/types"
+
+	"github.com/gin-gonic/gin"
+)
+
+func RelayTranscriptions(c *gin.Context) {
+
+	var audioRequest types.AudioRequest
+
+	if err := common.UnmarshalBodyReusable(c, &audioRequest); err != nil {
+		common.AbortWithMessage(c, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	channel, pass := fetchChannel(c, audioRequest.Model)
+	if pass {
+		return
+	}
+
+	// 解析模型映射
+	var isModelMapped bool
+	modelMap, err := parseModelMapping(channel.GetModelMapping())
+	if err != nil {
+		common.AbortWithMessage(c, http.StatusInternalServerError, err.Error())
+		return
+	}
+	if modelMap != nil && modelMap[audioRequest.Model] != "" {
+		audioRequest.Model = modelMap[audioRequest.Model]
+		isModelMapped = true
+	}
+
+	// 获取供应商
+	provider, pass := getProvider(c, channel, common.RelayModeAudioTranscription)
+	if pass {
+		return
+	}
+	transcriptionsProvider, ok := provider.(providersBase.TranscriptionsInterface)
+	if !ok {
+		common.AbortWithMessage(c, http.StatusNotImplemented, "channel not implemented")
+		return
+	}
+
+	// 获取Input Tokens
+	promptTokens := 0
+
+	var quotaInfo *QuotaInfo
+	var errWithCode *types.OpenAIErrorWithStatusCode
+	var usage *types.Usage
+	quotaInfo, errWithCode = generateQuotaInfo(c, audioRequest.Model, promptTokens)
+	if errWithCode != nil {
+		errorHelper(c, errWithCode)
+		return
+	}
+
+	usage, errWithCode = transcriptionsProvider.TranscriptionsAction(&audioRequest, isModelMapped, promptTokens)
+
+	// 如果报错，则退还配额
+	if errWithCode != nil {
+		tokenId := c.GetInt("token_id")
+		if quotaInfo.HandelStatus {
+			go func(ctx context.Context) {
+				// return pre-consumed quota
+				err := model.PostConsumeTokenQuota(tokenId, -quotaInfo.preConsumedQuota)
+				if err != nil {
+					common.LogError(ctx, "error return pre-consumed quota: "+err.Error())
+				}
+			}(c.Request.Context())
+		}
+		errorHelper(c, errWithCode)
+		return
+	} else {
+		tokenName := c.GetString("token_name")
+		// 如果没有报错，则消费配额
+		go func(ctx context.Context) {
+			err = quotaInfo.completedQuotaConsumption(usage, tokenName, ctx)
+			if err != nil {
+				common.LogError(ctx, err.Error())
+			}
+		}(c.Request.Context())
+	}
+}

controller/relay-translations.go

@@ -0,0 +1,89 @@
+package controller
+
+import (
+	"context"
+	"net/http"
+	"one-api/common"
+	"one-api/model"
+	providersBase "one-api/providers/base"
+	"one-api/types"
+
+	"github.com/gin-gonic/gin"
+)
+
+func RelayTranslations(c *gin.Context) {
+
+	var audioRequest types.AudioRequest
+
+	if err := common.UnmarshalBodyReusable(c, &audioRequest); err != nil {
+		common.AbortWithMessage(c, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	channel, pass := fetchChannel(c, audioRequest.Model)
+	if pass {
+		return
+	}
+
+	// 解析模型映射
+	var isModelMapped bool
+	modelMap, err := parseModelMapping(channel.GetModelMapping())
+	if err != nil {
+		common.AbortWithMessage(c, http.StatusInternalServerError, err.Error())
+		return
+	}
+	if modelMap != nil && modelMap[audioRequest.Model] != "" {
+		audioRequest.Model = modelMap[audioRequest.Model]
+		isModelMapped = true
+	}
+
+	// 获取供应商
+	provider, pass := getProvider(c, channel, common.RelayModeAudioTranslation)
+	if pass {
+		return
+	}
+	translationProvider, ok := provider.(providersBase.TranslationInterface)
+	if !ok {
+		common.AbortWithMessage(c, http.StatusNotImplemented, "channel not implemented")
+		return
+	}
+
+	// 获取Input Tokens
+	promptTokens := 0
+
+	var quotaInfo *QuotaInfo
+	var errWithCode *types.OpenAIErrorWithStatusCode
+	var usage *types.Usage
+	quotaInfo, errWithCode = generateQuotaInfo(c, audioRequest.Model, promptTokens)
+	if errWithCode != nil {
+		errorHelper(c, errWithCode)
+		return
+	}
+
+	usage, errWithCode = translationProvider.TranslationAction(&audioRequest, isModelMapped, promptTokens)
+
+	// 如果报错，则退还配额
+	if errWithCode != nil {
+		tokenId := c.GetInt("token_id")
+		if quotaInfo.HandelStatus {
+			go func(ctx context.Context) {
+				// return pre-consumed quota
+				err := model.PostConsumeTokenQuota(tokenId, -quotaInfo.preConsumedQuota)
+				if err != nil {
+					common.LogError(ctx, "error return pre-consumed quota: "+err.Error())
+				}
+			}(c.Request.Context())
+		}
+		errorHelper(c, errWithCode)
+		return
+	} else {
+		tokenName := c.GetString("token_name")
+		// 如果没有报错，则消费配额
+		go func(ctx context.Context) {
+			err = quotaInfo.completedQuotaConsumption(usage, tokenName, ctx)
+			if err != nil {
+				common.LogError(ctx, err.Error())
+			}
+		}(c.Request.Context())
+	}
+}

controller/relay-utils.go

@@ -5,228 +5,100 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io"
 	"math"
 	"net/http"
 	"one-api/common"
-	"one-api/common/image"
 	"one-api/model"
+	"one-api/providers"
+	providersBase "one-api/providers/base"
+	"one-api/types"
+	"reflect"
 	"strconv"
-	"strings"
 
 	"github.com/gin-gonic/gin"
-	"github.com/pkoukk/tiktoken-go"
+	"github.com/go-playground/validator/v10"
 )
 
-var stopFinishReason = "stop"
-
-// tokenEncoderMap won't grow after initialization
-var tokenEncoderMap = map[string]*tiktoken.Tiktoken{}
-var defaultTokenEncoder *tiktoken.Tiktoken
-
-func InitTokenEncoders() {
-	common.SysLog("initializing token encoders")
-	gpt35TokenEncoder, err := tiktoken.EncodingForModel("gpt-3.5-turbo")
-	if err != nil {
-		common.FatalLog(fmt.Sprintf("failed to get gpt-3.5-turbo token encoder: %s", err.Error()))
-	}
-	defaultTokenEncoder = gpt35TokenEncoder
-	gpt4TokenEncoder, err := tiktoken.EncodingForModel("gpt-4")
-	if err != nil {
-		common.FatalLog(fmt.Sprintf("failed to get gpt-4 token encoder: %s", err.Error()))
-	}
-	for model, _ := range common.ModelRatio {
-		if strings.HasPrefix(model, "gpt-3.5") {
-			tokenEncoderMap[model] = gpt35TokenEncoder
-		} else if strings.HasPrefix(model, "gpt-4") {
-			tokenEncoderMap[model] = gpt4TokenEncoder
-		} else {
-			tokenEncoderMap[model] = nil
+func GetValidFieldName(err error, obj interface{}) string {
+	getObj := reflect.TypeOf(obj)
+	if errs, ok := err.(validator.ValidationErrors); ok {
+		for _, e := range errs {
+			if f, exist := getObj.Elem().FieldByName(e.Field()); exist {
+				return f.Name
+			}
 		}
 	}
-	common.SysLog("token encoders initialized")
+	return err.Error()
 }
 
-func getTokenEncoder(model string) *tiktoken.Tiktoken {
-	tokenEncoder, ok := tokenEncoderMap[model]
-	if ok && tokenEncoder != nil {
-		return tokenEncoder
-	}
+func fetchChannel(c *gin.Context, modelName string) (channel *model.Channel, pass bool) {
+	channelId, ok := c.Get("channelId")
 	if ok {
-		tokenEncoder, err := tiktoken.EncodingForModel(model)
-		if err != nil {
-			common.SysError(fmt.Sprintf("failed to get token encoder for model %s: %s, using encoder for gpt-3.5-turbo", model, err.Error()))
-			tokenEncoder = defaultTokenEncoder
+		channel, pass = fetchChannelById(c, channelId.(int))
+		if pass {
+			return
 		}
-		tokenEncoderMap[model] = tokenEncoder
-		return tokenEncoder
+
 	}
-	return defaultTokenEncoder
+	channel, pass = fetchChannelByModel(c, modelName)
+	if pass {
+		return
+	}
+
+	return
 }
 
-func getTokenNum(tokenEncoder *tiktoken.Tiktoken, text string) int {
-	if common.ApproximateTokenEnabled {
-		return int(float64(len(text)) * 0.38)
+func fetchChannelById(c *gin.Context, channelId any) (*model.Channel, bool) {
+	id, err := strconv.Atoi(channelId.(string))
+	if err != nil {
+		common.AbortWithMessage(c, http.StatusBadRequest, "无效的渠道 Id")
+		return nil, true
 	}
-	return len(tokenEncoder.Encode(text, nil, nil))
+	channel, err := model.GetChannelById(id, true)
+	if err != nil {
+		common.AbortWithMessage(c, http.StatusBadRequest, "无效的渠道 Id")
+		return nil, true
+	}
+	if channel.Status != common.ChannelStatusEnabled {
+		common.AbortWithMessage(c, http.StatusForbidden, "该渠道已被禁用")
+		return nil, true
+	}
+
+	return channel, false
 }
 
-func countTokenMessages(messages []Message, model string) int {
-	tokenEncoder := getTokenEncoder(model)
-	// Reference:
-	// https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
-	// https://github.com/pkoukk/tiktoken-go/issues/6
-	//
-	// Every message follows <|start|>{role/name}\n{content}<|end|>\n
-	var tokensPerMessage int
-	var tokensPerName int
-	if model == "gpt-3.5-turbo-0301" {
-		tokensPerMessage = 4
-		tokensPerName = -1 // If there's a name, the role is omitted
-	} else {
-		tokensPerMessage = 3
-		tokensPerName = 1
-	}
-	tokenNum := 0
-	for _, message := range messages {
-		tokenNum += tokensPerMessage
-		switch v := message.Content.(type) {
-		case string:
-			tokenNum += getTokenNum(tokenEncoder, v)
-		case []any:
-			for _, it := range v {
-				m := it.(map[string]any)
-				switch m["type"] {
-				case "text":
-					tokenNum += getTokenNum(tokenEncoder, m["text"].(string))
-				case "image_url":
-					imageUrl, ok := m["image_url"].(map[string]any)
-					if ok {
-						url := imageUrl["url"].(string)
-						detail := ""
-						if imageUrl["detail"] != nil {
-							detail = imageUrl["detail"].(string)
-						}
-						imageTokens, err := countImageTokens(url, detail)
-						if err != nil {
-							common.SysError("error counting image tokens: " + err.Error())
-						} else {
-							tokenNum += imageTokens
-						}
-					}
-				}
-			}
-		}
-		tokenNum += getTokenNum(tokenEncoder, message.Role)
-		if message.Name != nil {
-			tokenNum += tokensPerName
-			tokenNum += getTokenNum(tokenEncoder, *message.Name)
+func fetchChannelByModel(c *gin.Context, modelName string) (*model.Channel, bool) {
+	group := c.GetString("group")
+	channel, err := model.CacheGetRandomSatisfiedChannel(group, modelName)
+	if err != nil {
+		message := fmt.Sprintf("当前分组 %s 下对于模型 %s 无可用渠道", group, modelName)
+		if channel != nil {
+			common.SysError(fmt.Sprintf("渠道不存在：%d", channel.Id))
+			message = "数据库一致性已被破坏，请联系管理员"
 		}
+		common.AbortWithMessage(c, http.StatusServiceUnavailable, message)
+		return nil, true
 	}
-	tokenNum += 3 // Every reply is primed with <|start|>assistant<|message|>
-	return tokenNum
+
+	return channel, false
 }
 
-const (
-	lowDetailCost         = 85
-	highDetailCostPerTile = 170
-	additionalCost        = 85
-)
-
-// https://platform.openai.com/docs/guides/vision/calculating-costs
-// https://github.com/openai/openai-cookbook/blob/05e3f9be4c7a2ae7ecf029a7c32065b024730ebe/examples/How_to_count_tokens_with_tiktoken.ipynb
-func countImageTokens(url string, detail string) (_ int, err error) {
-	var fetchSize = true
-	var width, height int
-	// Reference: https://platform.openai.com/docs/guides/vision/low-or-high-fidelity-image-understanding
-	// detail == "auto" is undocumented on how it works, it just said the model will use the auto setting which will look at the image input size and decide if it should use the low or high setting.
-	// According to the official guide, "low" disable the high-res model,
-	// and only receive low-res 512px x 512px version of the image, indicating
-	// that image is treated as low-res when size is smaller than 512px x 512px,
-	// then we can assume that image size larger than 512px x 512px is treated
-	// as high-res. Then we have the following logic:
-	// if detail == "" || detail == "auto" {
-	// 	width, height, err = image.GetImageSize(url)
-	// 	if err != nil {
-	// 		return 0, err
-	// 	}
-	// 	fetchSize = false
-	// 	// not sure if this is correct
-	// 	if width > 512 || height > 512 {
-	// 		detail = "high"
-	// 	} else {
-	// 		detail = "low"
-	// 	}
-	// }
-
-	// However, in my test, it seems to be always the same as "high".
-	// The following image, which is 125x50, is still treated as high-res, taken
-	// 255 tokens in the response of non-stream chat completion api.
-	// https://upload.wikimedia.org/wikipedia/commons/1/10/18_Infantry_Division_Messina.jpg
-	if detail == "" || detail == "auto" {
-		// assume by test, not sure if this is correct
-		detail = "high"
+func getProvider(c *gin.Context, channel *model.Channel, relayMode int) (providersBase.ProviderInterface, bool) {
+	provider := providers.GetProvider(channel, c)
+	if provider == nil {
+		common.AbortWithMessage(c, http.StatusNotImplemented, "channel not found")
+		return nil, true
 	}
-	switch detail {
-	case "low":
-		return lowDetailCost, nil
-	case "high":
-		if fetchSize {
-			width, height, err = image.GetImageSize(url)
-			if err != nil {
-				return 0, err
-			}
-		}
-		if width > 2048 || height > 2048 { // max(width, height) > 2048
-			ratio := float64(2048) / math.Max(float64(width), float64(height))
-			width = int(float64(width) * ratio)
-			height = int(float64(height) * ratio)
-		}
-		if width > 768 && height > 768 { // min(width, height) > 768
-			ratio := float64(768) / math.Min(float64(width), float64(height))
-			width = int(float64(width) * ratio)
-			height = int(float64(height) * ratio)
-		}
-		numSquares := int(math.Ceil(float64(width)/512) * math.Ceil(float64(height)/512))
-		result := numSquares*highDetailCostPerTile + additionalCost
-		return result, nil
-	default:
-		return 0, errors.New("invalid detail option")
+
+	if !provider.SupportAPI(relayMode) {
+		common.AbortWithMessage(c, http.StatusNotImplemented, "channel does not support this API")
+		return nil, true
 	}
+
+	return provider, false
 }
 
-func countTokenInput(input any, model string) int {
-	switch v := input.(type) {
-	case string:
-		return countTokenText(v, model)
-	case []string:
-		text := ""
-		for _, s := range v {
-			text += s
-		}
-		return countTokenText(text, model)
-	}
-	return 0
-}
-
-func countTokenText(text string, model string) int {
-	tokenEncoder := getTokenEncoder(model)
-	return getTokenNum(tokenEncoder, text)
-}
-
-func errorWrapper(err error, code string, statusCode int) *OpenAIErrorWithStatusCode {
-	openAIError := OpenAIError{
-		Message: err.Error(),
-		Type:    "one_api_error",
-		Code:    code,
-	}
-	return &OpenAIErrorWithStatusCode{
-		OpenAIError: openAIError,
-		StatusCode:  statusCode,
-	}
-}
-
-func shouldDisableChannel(err *OpenAIError, statusCode int) bool {
+func shouldDisableChannel(err *types.OpenAIError, statusCode int) bool {
 	if !common.AutomaticDisableChannelEnabled {
 		return false
 	}
@@ -242,7 +114,7 @@ func shouldDisableChannel(err *OpenAIError, statusCode int) bool {
 	return false
 }
 
-func shouldEnableChannel(err error, openAIErr *OpenAIError) bool {
+func shouldEnableChannel(err error, openAIErr *types.OpenAIError) bool {
 	if !common.AutomaticEnableChannelEnabled {
 		return false
 	}
@@ -255,104 +127,6 @@ func shouldEnableChannel(err error, openAIErr *OpenAIError) bool {
 	return true
 }
 
-func setEventStreamHeaders(c *gin.Context) {
-	c.Writer.Header().Set("Content-Type", "text/event-stream")
-	c.Writer.Header().Set("Cache-Control", "no-cache")
-	c.Writer.Header().Set("Connection", "keep-alive")
-	c.Writer.Header().Set("Transfer-Encoding", "chunked")
-	c.Writer.Header().Set("X-Accel-Buffering", "no")
-}
-
-type GeneralErrorResponse struct {
-	Error    OpenAIError `json:"error"`
-	Message  string      `json:"message"`
-	Msg      string      `json:"msg"`
-	Err      string      `json:"err"`
-	ErrorMsg string      `json:"error_msg"`
-	Header   struct {
-		Message string `json:"message"`
-	} `json:"header"`
-	Response struct {
-		Error struct {
-			Message string `json:"message"`
-		} `json:"error"`
-	} `json:"response"`
-}
-
-func (e GeneralErrorResponse) ToMessage() string {
-	if e.Error.Message != "" {
-		return e.Error.Message
-	}
-	if e.Message != "" {
-		return e.Message
-	}
-	if e.Msg != "" {
-		return e.Msg
-	}
-	if e.Err != "" {
-		return e.Err
-	}
-	if e.ErrorMsg != "" {
-		return e.ErrorMsg
-	}
-	if e.Header.Message != "" {
-		return e.Header.Message
-	}
-	if e.Response.Error.Message != "" {
-		return e.Response.Error.Message
-	}
-	return ""
-}
-
-func relayErrorHandler(resp *http.Response) (openAIErrorWithStatusCode *OpenAIErrorWithStatusCode) {
-	openAIErrorWithStatusCode = &OpenAIErrorWithStatusCode{
-		StatusCode: resp.StatusCode,
-		OpenAIError: OpenAIError{
-			Message: "",
-			Type:    "upstream_error",
-			Code:    "bad_response_status_code",
-			Param:   strconv.Itoa(resp.StatusCode),
-		},
-	}
-	responseBody, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return
-	}
-	err = resp.Body.Close()
-	if err != nil {
-		return
-	}
-	var errResponse GeneralErrorResponse
-	err = json.Unmarshal(responseBody, &errResponse)
-	if err != nil {
-		return
-	}
-	if errResponse.Error.Message != "" {
-		// OpenAI format error, so we override the default one
-		openAIErrorWithStatusCode.OpenAIError = errResponse.Error
-	} else {
-		openAIErrorWithStatusCode.OpenAIError.Message = errResponse.ToMessage()
-	}
-	if openAIErrorWithStatusCode.OpenAIError.Message == "" {
-		openAIErrorWithStatusCode.OpenAIError.Message = fmt.Sprintf("bad response status code %d", resp.StatusCode)
-	}
-	return
-}
-
-func getFullRequestURL(baseURL string, requestURL string, channelType int) string {
-	fullRequestURL := fmt.Sprintf("%s%s", baseURL, requestURL)
-
-	if strings.HasPrefix(baseURL, "https://gateway.ai.cloudflare.com") {
-		switch channelType {
-		case common.ChannelTypeOpenAI:
-			fullRequestURL = fmt.Sprintf("%s%s", baseURL, strings.TrimPrefix(requestURL, "/v1"))
-		case common.ChannelTypeAzure:
-			fullRequestURL = fmt.Sprintf("%s%s", baseURL, strings.TrimPrefix(requestURL, "/openai/deployments"))
-		}
-	}
-	return fullRequestURL
-}
-
 func postConsumeQuota(ctx context.Context, tokenId int, quotaDelta int, totalQuota int, userId int, channelId int, modelRatio float64, groupRatio float64, modelName string, tokenName string) {
 	// quotaDelta is remaining quota to be consumed
 	err := model.PostConsumeTokenQuota(tokenId, quotaDelta)
@@ -375,11 +149,130 @@ func postConsumeQuota(ctx context.Context, tokenId int, quotaDelta int, totalQuo
 	}
 }
 
-func GetAPIVersion(c *gin.Context) string {
-	query := c.Request.URL.Query()
-	apiVersion := query.Get("api-version")
-	if apiVersion == "" {
-		apiVersion = c.GetString("api_version")
+func parseModelMapping(modelMapping string) (map[string]string, error) {
+	if modelMapping == "" || modelMapping == "{}" {
+		return nil, nil
 	}
-	return apiVersion
+	modelMap := make(map[string]string)
+	err := json.Unmarshal([]byte(modelMapping), &modelMap)
+	if err != nil {
+		return nil, err
+	}
+	return modelMap, nil
+}
+
+type QuotaInfo struct {
+	modelName         string
+	promptTokens      int
+	preConsumedTokens int
+	modelRatio        float64
+	groupRatio        float64
+	ratio             float64
+	preConsumedQuota  int
+	userId            int
+	channelId         int
+	tokenId           int
+	HandelStatus      bool
+}
+
+func generateQuotaInfo(c *gin.Context, modelName string, promptTokens int) (*QuotaInfo, *types.OpenAIErrorWithStatusCode) {
+	quotaInfo := &QuotaInfo{
+		modelName:    modelName,
+		promptTokens: promptTokens,
+		userId:       c.GetInt("id"),
+		channelId:    c.GetInt("channel_id"),
+		tokenId:      c.GetInt("token_id"),
+		HandelStatus: false,
+	}
+	quotaInfo.initQuotaInfo(c.GetString("group"))
+
+	errWithCode := quotaInfo.preQuotaConsumption()
+	if errWithCode != nil {
+		return nil, errWithCode
+	}
+
+	return quotaInfo, nil
+}
+
+func (q *QuotaInfo) initQuotaInfo(groupName string) {
+	modelRatio := common.GetModelRatio(q.modelName)
+	groupRatio := common.GetGroupRatio(groupName)
+	preConsumedTokens := common.PreConsumedQuota
+	ratio := modelRatio * groupRatio
+	preConsumedQuota := int(float64(q.promptTokens+preConsumedTokens) * ratio)
+
+	q.preConsumedTokens = preConsumedTokens
+	q.modelRatio = modelRatio
+	q.groupRatio = groupRatio
+	q.ratio = ratio
+	q.preConsumedQuota = preConsumedQuota
+
+	return
+}
+
+func (q *QuotaInfo) preQuotaConsumption() *types.OpenAIErrorWithStatusCode {
+	userQuota, err := model.CacheGetUserQuota(q.userId)
+	if err != nil {
+		return common.ErrorWrapper(err, "get_user_quota_failed", http.StatusInternalServerError)
+	}
+
+	if userQuota < q.preConsumedQuota {
+		return common.ErrorWrapper(errors.New("user quota is not enough"), "insufficient_user_quota", http.StatusForbidden)
+	}
+
+	err = model.CacheDecreaseUserQuota(q.userId, q.preConsumedQuota)
+	if err != nil {
+		return common.ErrorWrapper(err, "decrease_user_quota_failed", http.StatusInternalServerError)
+	}
+
+	if userQuota > 100*q.preConsumedQuota {
+		// in this case, we do not pre-consume quota
+		// because the user has enough quota
+		q.preConsumedQuota = 0
+		// common.LogInfo(c.Request.Context(), fmt.Sprintf("user %d has enough quota %d, trusted and no need to pre-consume", userId, userQuota))
+	}
+
+	if q.preConsumedQuota > 0 {
+		err := model.PreConsumeTokenQuota(q.tokenId, q.preConsumedQuota)
+		if err != nil {
+			return common.ErrorWrapper(err, "pre_consume_token_quota_failed", http.StatusForbidden)
+		}
+		q.HandelStatus = true
+	}
+
+	return nil
+}
+
+func (q *QuotaInfo) completedQuotaConsumption(usage *types.Usage, tokenName string, ctx context.Context) error {
+	quota := 0
+	completionRatio := common.GetCompletionRatio(q.modelName)
+	promptTokens := usage.PromptTokens
+	completionTokens := usage.CompletionTokens
+	quota = int(math.Ceil((float64(promptTokens) + float64(completionTokens)*completionRatio) * q.ratio))
+	if q.ratio != 0 && quota <= 0 {
+		quota = 1
+	}
+	totalTokens := promptTokens + completionTokens
+	if totalTokens == 0 {
+		// in this case, must be some error happened
+		// we cannot just return, because we may have to return the pre-consumed quota
+		quota = 0
+	}
+	quotaDelta := quota - q.preConsumedQuota
+	err := model.PostConsumeTokenQuota(q.tokenId, quotaDelta)
+	if err != nil {
+		return errors.New("error consuming token remain quota: " + err.Error())
+	}
+	err = model.CacheUpdateUserQuota(q.userId)
+	if err != nil {
+		return errors.New("error consuming token remain quota: " + err.Error())
+	}
+	if quota != 0 {
+		logContent := fmt.Sprintf("模型倍率 %.2f，分组倍率 %.2f", q.modelRatio, q.groupRatio)
+		model.RecordConsumeLog(ctx, q.userId, q.channelId, promptTokens, completionTokens, q.modelName, tokenName, quota, logContent)
+		model.UpdateUserUsedQuotaAndRequestCount(q.userId, quota)
+		model.UpdateChannelUsedQuota(q.channelId, quota)
+	}
+
+	return nil
 }

controller/relay-xunfei.go

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

controller/relay-zhipu.go

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

controller/relay.go

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

controller/token.go

@@ -1,11 +1,12 @@
 package controller
 
 import (
-	"github.com/gin-gonic/gin"
 	"net/http"
 	"one-api/common"
 	"one-api/model"
 	"strconv"
+
+	"github.com/gin-gonic/gin"
 )
 
 func GetAllTokens(c *gin.Context) {
@@ -27,7 +28,6 @@ func GetAllTokens(c *gin.Context) {
 		"message": "",
 		"data":    tokens,
 	})
-	return
 }
 
 func SearchTokens(c *gin.Context) {
@@ -46,7 +46,6 @@ func SearchTokens(c *gin.Context) {
 		"message": "",
 		"data":    tokens,
 	})
-	return
 }
 
 func GetToken(c *gin.Context) {
@@ -72,7 +71,6 @@ func GetToken(c *gin.Context) {
 		"message": "",
 		"data":    token,
 	})
-	return
 }
 
 func GetTokenStatus(c *gin.Context) {
@@ -138,7 +136,6 @@ func AddToken(c *gin.Context) {
 		"success": true,
 		"message": "",
 	})
-	return
 }
 
 func DeleteToken(c *gin.Context) {
@@ -156,7 +153,6 @@ func DeleteToken(c *gin.Context) {
 		"success": true,
 		"message": "",
 	})
-	return
 }
 
 func UpdateToken(c *gin.Context) {
@@ -224,5 +220,4 @@ func UpdateToken(c *gin.Context) {
 		"message": "",
 		"data":    cleanToken,
 	})
-	return
 }

controller/user.go

@@ -7,6 +7,7 @@ import (
 	"one-api/common"
 	"one-api/model"
 	"strconv"
+	"time"
 
 	"github.com/gin-contrib/sessions"
 	"github.com/gin-gonic/gin"
@@ -173,7 +174,6 @@ func Register(c *gin.Context) {
 		"success": true,
 		"message": "",
 	})
-	return
 }
 
 func GetAllUsers(c *gin.Context) {
@@ -194,7 +194,6 @@ func GetAllUsers(c *gin.Context) {
 		"message": "",
 		"data":    users,
 	})
-	return
 }
 
 func SearchUsers(c *gin.Context) {
@@ -212,7 +211,6 @@ func SearchUsers(c *gin.Context) {
 		"message": "",
 		"data":    users,
 	})
-	return
 }
 
 func GetUser(c *gin.Context) {
@@ -245,7 +243,30 @@ func GetUser(c *gin.Context) {
 		"message": "",
 		"data":    user,
 	})
-	return
+}
+
+func GetUserDashboard(c *gin.Context) {
+	id := c.GetInt("id")
+	// 获取7天前 00:00:00 和 今天23:59:59  的秒时间戳
+	now := time.Now()
+	toDay := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
+	endOfDay := toDay.Add(time.Hour * 24).Add(-time.Second).Unix()
+	startOfDay := toDay.AddDate(0, 0, -7).Unix()
+
+	dashboards, err := model.SearchLogsByDayAndModel(id, int(startOfDay), int(endOfDay))
+	if err != nil {
+		c.JSON(http.StatusOK, gin.H{
+			"success": false,
+			"message": "无法获取统计信息.",
+		})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"success": true,
+		"message": "",
+		"data":    dashboards,
+	})
 }
 
 func GenerateAccessToken(c *gin.Context) {
@@ -281,7 +302,6 @@ func GenerateAccessToken(c *gin.Context) {
 		"message": "",
 		"data":    user.AccessToken,
 	})
-	return
 }
 
 func GetAffCode(c *gin.Context) {
@@ -309,7 +329,6 @@ func GetAffCode(c *gin.Context) {
 		"message": "",
 		"data":    user.AffCode,
 	})
-	return
 }
 
 func GetSelf(c *gin.Context) {
@@ -327,7 +346,6 @@ func GetSelf(c *gin.Context) {
 		"message": "",
 		"data":    user,
 	})
-	return
 }
 
 func UpdateUser(c *gin.Context) {
@@ -391,7 +409,6 @@ func UpdateUser(c *gin.Context) {
 		"success": true,
 		"message": "",
 	})
-	return
 }
 
 func UpdateSelf(c *gin.Context) {
@@ -438,7 +455,6 @@ func UpdateSelf(c *gin.Context) {
 		"success": true,
 		"message": "",
 	})
-	return
 }
 
 func DeleteUser(c *gin.Context) {
@@ -500,7 +516,6 @@ func DeleteSelf(c *gin.Context) {
 		"success": true,
 		"message": "",
 	})
-	return
 }
 
 func CreateUser(c *gin.Context) {
@@ -549,7 +564,6 @@ func CreateUser(c *gin.Context) {
 		"success": true,
 		"message": "",
 	})
-	return
 }
 
 type ManageRequest struct {
@@ -666,7 +680,6 @@ func ManageUser(c *gin.Context) {
 		"message": "",
 		"data":    clearUser,
 	})
-	return
 }
 
 func EmailBind(c *gin.Context) {
@@ -708,7 +721,6 @@ func EmailBind(c *gin.Context) {
 		"success": true,
 		"message": "",
 	})
-	return
 }
 
 type topUpRequest struct {
@@ -739,5 +751,4 @@ func TopUp(c *gin.Context) {
 		"message": "",
 		"data":    quota,
 	})
-	return
 }

controller/wechat.go

@@ -4,12 +4,13 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/gin-gonic/gin"
 	"net/http"
 	"one-api/common"
 	"one-api/model"
 	"strconv"
 	"time"
+
+	"github.com/gin-gonic/gin"
 )
 
 type wechatLoginResponse struct {
@@ -160,5 +161,4 @@ func WeChatBind(c *gin.Context) {
 		"success": true,
 		"message": "",
 	})
-	return
 }

go.mod

@@ -45,6 +45,7 @@ require (
 	github.com/jackc/pgx/v5 v5.3.1 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
+	github.com/joho/godotenv v1.5.1 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.4 // indirect
 	github.com/leodido/go-urn v1.2.4 // indirect
@@ -57,7 +58,7 @@ require (
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.2.11 // indirect
 	golang.org/x/arch v0.3.0 // indirect
-	golang.org/x/net v0.17.0 // indirect
+	golang.org/x/net v0.19.0 // indirect
 	golang.org/x/sys v0.15.0 // indirect
 	golang.org/x/text v0.14.0 // indirect
 	google.golang.org/protobuf v1.30.0 // indirect

go.sum

@@ -80,6 +80,8 @@ github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkr
 github.com/jinzhu/now v1.1.4/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
 github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
 github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
+github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
+github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
 github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
@@ -157,6 +159,8 @@ golang.org/x/image v0.14.0/go.mod h1:HUYqC05R2ZcZ3ejNQsIHQDQiwWM4JBqmm6MKANTp4LE
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM=
 golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
+golang.org/x/net v0.19.0 h1:zTwKpTd2XuCqf8huc7Fo2iSy+4RHPd10s4KzeTnVr1c=
+golang.org/x/net v0.19.0/go.mod h1:CfAk/cbD4CthTvqiEl8NpboMuiuOYsAr/7NOjZJtv1U=
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

main.go

@@ -3,9 +3,6 @@ package main
 import (
 	"embed"
 	"fmt"
-	"github.com/gin-contrib/sessions"
-	"github.com/gin-contrib/sessions/cookie"
-	"github.com/gin-gonic/gin"
 	"one-api/common"
 	"one-api/controller"
 	"one-api/middleware"
@@ -13,6 +10,10 @@ import (
 	"one-api/router"
 	"os"
 	"strconv"
+
+	"github.com/gin-contrib/sessions"
+	"github.com/gin-contrib/sessions/cookie"
+	"github.com/gin-gonic/gin"
 )
 
 //go:embed web/build
@@ -82,7 +83,7 @@ func main() {
 		common.SysLog("batch update enabled with interval " + strconv.Itoa(common.BatchUpdateInterval) + "s")
 		model.InitBatchUpdater()
 	}
-	controller.InitTokenEncoders()
+	common.InitTokenEncoders()
 
 	// Initialize HTTP server
 	server := gin.New()

middleware/distributor.go

@@ -1,99 +1,16 @@
 package middleware
 
 import (
-	"fmt"
-	"net/http"
-	"one-api/common"
 	"one-api/model"
-	"strconv"
-	"strings"
 
 	"github.com/gin-gonic/gin"
 )
 
-type ModelRequest struct {
-	Model string `json:"model"`
-}
-
 func Distribute() func(c *gin.Context) {
 	return func(c *gin.Context) {
 		userId := c.GetInt("id")
 		userGroup, _ := model.CacheGetUserGroup(userId)
 		c.Set("group", userGroup)
-		var channel *model.Channel
-		channelId, ok := c.Get("channelId")
-		if ok {
-			id, err := strconv.Atoi(channelId.(string))
-			if err != nil {
-				abortWithMessage(c, http.StatusBadRequest, "无效的渠道 Id")
-				return
-			}
-			channel, err = model.GetChannelById(id, true)
-			if err != nil {
-				abortWithMessage(c, http.StatusBadRequest, "无效的渠道 Id")
-				return
-			}
-			if channel.Status != common.ChannelStatusEnabled {
-				abortWithMessage(c, http.StatusForbidden, "该渠道已被禁用")
-				return
-			}
-		} else {
-			// Select a channel for the user
-			var modelRequest ModelRequest
-			err := common.UnmarshalBodyReusable(c, &modelRequest)
-			if err != nil {
-				abortWithMessage(c, http.StatusBadRequest, "无效的请求")
-				return
-			}
-			if strings.HasPrefix(c.Request.URL.Path, "/v1/moderations") {
-				if modelRequest.Model == "" {
-					modelRequest.Model = "text-moderation-stable"
-				}
-			}
-			if strings.HasSuffix(c.Request.URL.Path, "embeddings") {
-				if modelRequest.Model == "" {
-					modelRequest.Model = c.Param("model")
-				}
-			}
-			if strings.HasPrefix(c.Request.URL.Path, "/v1/images/generations") {
-				if modelRequest.Model == "" {
-					modelRequest.Model = "dall-e-2"
-				}
-			}
-			if strings.HasPrefix(c.Request.URL.Path, "/v1/audio/transcriptions") || strings.HasPrefix(c.Request.URL.Path, "/v1/audio/translations") {
-				if modelRequest.Model == "" {
-					modelRequest.Model = "whisper-1"
-				}
-			}
-			channel, err = model.CacheGetRandomSatisfiedChannel(userGroup, modelRequest.Model)
-			if err != nil {
-				message := fmt.Sprintf("当前分组 %s 下对于模型 %s 无可用渠道", userGroup, modelRequest.Model)
-				if channel != nil {
-					common.SysError(fmt.Sprintf("渠道不存在：%d", channel.Id))
-					message = "数据库一致性已被破坏，请联系管理员"
-				}
-				abortWithMessage(c, http.StatusServiceUnavailable, message)
-				return
-			}
-		}
-		c.Set("channel", channel.Type)
-		c.Set("channel_id", channel.Id)
-		c.Set("channel_name", channel.Name)
-		c.Set("model_mapping", channel.GetModelMapping())
-		c.Request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", channel.Key))
-		c.Set("base_url", channel.GetBaseURL())
-		switch channel.Type {
-		case common.ChannelTypeAzure:
-			c.Set("api_version", channel.Other)
-		case common.ChannelTypeXunfei:
-			c.Set("api_version", channel.Other)
-		case common.ChannelTypeGemini:
-			c.Set("api_version", channel.Other)
-		case common.ChannelTypeAIProxyLibrary:
-			c.Set("library_id", channel.Other)
-		case common.ChannelTypeAli:
-			c.Set("plugin", channel.Other)
-		}
 		c.Next()
 	}
 }

model/channel.go

@@ -1,8 +1,9 @@
 package model
 
 import (
-	"gorm.io/gorm"
 	"one-api/common"
+
+	"gorm.io/gorm"
 )
 
 type Channel struct {
@@ -24,6 +25,7 @@ type Channel struct {
 	UsedQuota          int64   `json:"used_quota" gorm:"bigint;default:0"`
 	ModelMapping       *string `json:"model_mapping" gorm:"type:varchar(1024);default:''"`
 	Priority           *int64  `json:"priority" gorm:"bigint;default:0"`
+	Proxy              string  `json:"proxy" gorm:"type:varchar(255);default:''"`
 }
 
 func GetAllChannels(startIdx int, num int, selectAll bool) ([]*Channel, error) {

model/log.go

@@ -3,8 +3,9 @@ package model
 import (
 	"context"
 	"fmt"
-	"gorm.io/gorm"
 	"one-api/common"
+
+	"gorm.io/gorm"
 )
 
 type Log struct {
@@ -22,6 +23,15 @@ type Log struct {
 	ChannelId        int    `json:"channel" gorm:"index"`
 }
 
+type LogStatistic struct {
+	Day              string `gorm:"column:day"`
+	ModelName        string `gorm:"column:model_name"`
+	RequestCount     int    `gorm:"column:request_count"`
+	Quota            int    `gorm:"column:quota"`
+	PromptTokens     int    `gorm:"column:prompt_tokens"`
+	CompletionTokens int    `gorm:"column:completion_tokens"`
+}
+
 const (
 	LogTypeUnknown = iota
 	LogTypeTopup
@@ -134,7 +144,7 @@ func SearchUserLogs(userId int, keyword string) (logs []*Log, err error) {
 }
 
 func SumUsedQuota(logType int, startTimestamp int64, endTimestamp int64, modelName string, username string, tokenName string, channel int) (quota int) {
-	tx := DB.Table("logs").Select("ifnull(sum(quota),0)")
+	tx := DB.Table("logs").Select(assembleSumSelectStr("quota"))
 	if username != "" {
 		tx = tx.Where("username = ?", username)
 	}
@@ -158,7 +168,7 @@ func SumUsedQuota(logType int, startTimestamp int64, endTimestamp int64, modelNa
 }
 
 func SumUsedToken(logType int, startTimestamp int64, endTimestamp int64, modelName string, username string, tokenName string) (token int) {
-	tx := DB.Table("logs").Select("ifnull(sum(prompt_tokens),0) + ifnull(sum(completion_tokens),0)")
+	tx := DB.Table("logs").Select(assembleSumSelectStr("prompt_tokens") + " + " + assembleSumSelectStr("completion_tokens"))
 	if username != "" {
 		tx = tx.Where("username = ?", username)
 	}
@@ -182,3 +192,45 @@ func DeleteOldLog(targetTimestamp int64) (int64, error) {
 	result := DB.Where("created_at < ?", targetTimestamp).Delete(&Log{})
 	return result.RowsAffected, result.Error
 }
+
+func SearchLogsByDayAndModel(user_id, start, end int) (LogStatistics []*LogStatistic, err error) {
+	groupSelect := "DATE_FORMAT(FROM_UNIXTIME(created_at), '%Y-%m-%d') as day"
+
+	if common.UsingPostgreSQL {
+		groupSelect = "TO_CHAR(date_trunc('day', to_timestamp(created_at)), 'YYYY-MM-DD') as day"
+	}
+
+	if common.UsingSQLite {
+		groupSelect = "strftime('%Y-%m-%d', datetime(created_at, 'unixepoch')) as day"
+	}
+
+	err = DB.Raw(`
+		SELECT `+groupSelect+`,
+		model_name, count(1) as request_count,
+		sum(quota) as quota,
+		sum(prompt_tokens) as prompt_tokens,
+		sum(completion_tokens) as completion_tokens
+		FROM logs
+		WHERE type=2
+		AND user_id= ?
+		AND created_at BETWEEN ? AND ?
+		GROUP BY day, model_name
+		ORDER BY day, model_name
+	`, user_id, start, end).Scan(&LogStatistics).Error
+
+	fmt.Println(user_id, start, end)
+
+	return LogStatistics, err
+}
+
+func assembleSumSelectStr(selectStr string) string {
+	sumSelectStr := "%s(sum(%s),0)"
+	nullfunc := "ifnull"
+	if common.UsingPostgreSQL {
+		nullfunc = "coalesce"
+	}
+
+	sumSelectStr = fmt.Sprintf(sumSelectStr, nullfunc, selectStr)
+
+	return sumSelectStr
+}

model/redemption.go

@@ -3,8 +3,9 @@ package model
 import (
 	"errors"
 	"fmt"
-	"gorm.io/gorm"
 	"one-api/common"
+
+	"gorm.io/gorm"
 )
 
 type Redemption struct {
@@ -27,7 +28,7 @@ func GetAllRedemptions(startIdx int, num int) ([]*Redemption, error) {
 }
 
 func SearchRedemptions(keyword string) (redemptions []*Redemption, err error) {
-	err = DB.Where("id = ? or name LIKE ?", keyword, keyword+"%").Find(&redemptions).Error
+	err = DB.Where("id = ? or name LIKE ?", common.String2Int(keyword), keyword+"%").Find(&redemptions).Error
 	return redemptions, err
 }
 

model/user.go

@@ -3,9 +3,10 @@ package model
 import (
 	"errors"
 	"fmt"
-	"gorm.io/gorm"
 	"one-api/common"
 	"strings"
+
+	"gorm.io/gorm"
 )
 
 // User if you add sensitive fields, don't forget to clean them in setupLogin function.
@@ -42,11 +43,8 @@ func GetAllUsers(startIdx int, num int) (users []*User, err error) {
 }
 
 func SearchUsers(keyword string) (users []*User, err error) {
-	if !common.UsingPostgreSQL {
-		err = DB.Omit("password").Where("id = ? or username LIKE ? or email LIKE ? or display_name LIKE ?", keyword, keyword+"%", keyword+"%", keyword+"%").Find(&users).Error
-	} else {
-		err = DB.Omit("password").Where("username LIKE ? or email LIKE ? or display_name LIKE ?", keyword+"%", keyword+"%", keyword+"%").Find(&users).Error
-	}
+	err = DB.Omit("password").Where("id = ? or username LIKE ? or email LIKE ? or display_name LIKE ?", common.String2Int(keyword), keyword+"%", keyword+"%", keyword+"%").Find(&users).Error
+
 	return users, err
 }
 

providers/aigc2d/balance.go

@@ -0,0 +1,30 @@
+package aigc2d
+
+import (
+	"errors"
+	"one-api/common"
+	"one-api/model"
+	"one-api/providers/base"
+)
+
+func (p *Aigc2dProvider) Balance(channel *model.Channel) (float64, error) {
+	fullRequestURL := p.GetFullRequestURL("/dashboard/billing/credit_grants", "")
+	headers := p.GetRequestHeaders()
+
+	client := common.NewClient()
+	req, err := client.NewRequest("GET", fullRequestURL, common.WithHeader(headers))
+	if err != nil {
+		return 0, err
+	}
+
+	// 发送请求
+	var response base.BalanceResponse
+	_, errWithCode := common.SendRequest(req, &response, false, p.Channel.Proxy)
+	if errWithCode != nil {
+		return 0, errors.New(errWithCode.OpenAIError.Message)
+	}
+
+	channel.UpdateBalance(response.TotalAvailable)
+
+	return response.TotalAvailable, nil
+}

providers/aigc2d/base.go

@@ -0,0 +1,20 @@
+package aigc2d
+
+import (
+	"one-api/providers/base"
+	"one-api/providers/openai"
+
+	"github.com/gin-gonic/gin"
+)
+
+type Aigc2dProviderFactory struct{}
+
+func (f Aigc2dProviderFactory) Create(c *gin.Context) base.ProviderInterface {
+	return &Aigc2dProvider{
+		OpenAIProvider: openai.CreateOpenAIProvider(c, "https://api.aigc2d.com"),
+	}
+}
+
+type Aigc2dProvider struct {
+	*openai.OpenAIProvider
+}

providers/aiproxy/balance.go

@@ -0,0 +1,35 @@
+package aiproxy
+
+import (
+	"errors"
+	"fmt"
+	"one-api/common"
+	"one-api/model"
+)
+
+func (p *AIProxyProvider) Balance(channel *model.Channel) (float64, error) {
+	fullRequestURL := "https://aiproxy.io/api/report/getUserOverview"
+	headers := make(map[string]string)
+	headers["Api-Key"] = channel.Key
+
+	client := common.NewClient()
+	req, err := client.NewRequest("GET", fullRequestURL, common.WithHeader(headers))
+	if err != nil {
+		return 0, err
+	}
+
+	// 发送请求
+	var response AIProxyUserOverviewResponse
+	_, errWithCode := common.SendRequest(req, &response, false, p.Channel.Proxy)
+	if errWithCode != nil {
+		return 0, errors.New(errWithCode.OpenAIError.Message)
+	}
+
+	if !response.Success {
+		return 0, fmt.Errorf("code: %d, message: %s", response.ErrorCode, response.Message)
+	}
+
+	channel.UpdateBalance(response.Data.TotalPoints)
+
+	return response.Data.TotalPoints, nil
+}

providers/aiproxy/base.go

@@ -0,0 +1,20 @@
+package aiproxy
+
+import (
+	"one-api/providers/base"
+	"one-api/providers/openai"
+
+	"github.com/gin-gonic/gin"
+)
+
+type AIProxyProviderFactory struct{}
+
+func (f AIProxyProviderFactory) Create(c *gin.Context) base.ProviderInterface {
+	return &AIProxyProvider{
+		OpenAIProvider: openai.CreateOpenAIProvider(c, "https://api.aiproxy.io"),
+	}
+}
+
+type AIProxyProvider struct {
+	*openai.OpenAIProvider
+}

providers/aiproxy/type.go

@@ -0,0 +1,10 @@
+package aiproxy
+
+type AIProxyUserOverviewResponse struct {
+	Success   bool   `json:"success"`
+	Message   string `json:"message"`
+	ErrorCode int    `json:"error_code"`
+	Data      struct {
+		TotalPoints float64 `json:"totalPoints"`
+	} `json:"data"`
+}

providers/ali/base.go

@@ -0,0 +1,41 @@
+package ali
+
+import (
+	"fmt"
+
+	"one-api/providers/base"
+
+	"github.com/gin-gonic/gin"
+)
+
+// 定义供应商工厂
+type AliProviderFactory struct{}
+
+// 创建 AliProvider
+// https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation
+func (f AliProviderFactory) Create(c *gin.Context) base.ProviderInterface {
+	return &AliProvider{
+		BaseProvider: base.BaseProvider{
+			BaseURL:         "https://dashscope.aliyuncs.com",
+			ChatCompletions: "/api/v1/services/aigc/text-generation/generation",
+			Embeddings:      "/api/v1/services/embeddings/text-embedding/text-embedding",
+			Context:         c,
+		},
+	}
+}
+
+type AliProvider struct {
+	base.BaseProvider
+}
+
+// 获取请求头
+func (p *AliProvider) GetRequestHeaders() (headers map[string]string) {
+	headers = make(map[string]string)
+	p.CommonRequestHeaders(headers)
+	headers["Authorization"] = fmt.Sprintf("Bearer %s", p.Channel.Key)
+	if p.Channel.Other != "" {
+		headers["X-DashScope-Plugin"] = p.Channel.Other
+	}
+
+	return headers
+}

providers/ali/chat.go

@@ -0,0 +1,236 @@
+package ali
+
+import (
+	"bufio"
+	"encoding/json"
+	"io"
+	"net/http"
+	"one-api/common"
+	"one-api/types"
+	"strings"
+)
+
+// 阿里云响应处理
+func (aliResponse *AliChatResponse) ResponseHandler(resp *http.Response) (OpenAIResponse any, errWithCode *types.OpenAIErrorWithStatusCode) {
+	if aliResponse.Code != "" {
+		errWithCode = &types.OpenAIErrorWithStatusCode{
+			OpenAIError: types.OpenAIError{
+				Message: aliResponse.Message,
+				Type:    aliResponse.Code,
+				Param:   aliResponse.RequestId,
+				Code:    aliResponse.Code,
+			},
+			StatusCode: resp.StatusCode,
+		}
+
+		return
+	}
+
+	choice := types.ChatCompletionChoice{
+		Index: 0,
+		Message: types.ChatCompletionMessage{
+			Role:    "assistant",
+			Content: aliResponse.Output.Text,
+		},
+		FinishReason: aliResponse.Output.FinishReason,
+	}
+
+	OpenAIResponse = types.ChatCompletionResponse{
+		ID:      aliResponse.RequestId,
+		Object:  "chat.completion",
+		Created: common.GetTimestamp(),
+		Model:   aliResponse.Model,
+		Choices: []types.ChatCompletionChoice{choice},
+		Usage: &types.Usage{
+			PromptTokens:     aliResponse.Usage.InputTokens,
+			CompletionTokens: aliResponse.Usage.OutputTokens,
+			TotalTokens:      aliResponse.Usage.InputTokens + aliResponse.Usage.OutputTokens,
+		},
+	}
+
+	return
+}
+
+const AliEnableSearchModelSuffix = "-internet"
+
+// 获取聊天请求体
+func (p *AliProvider) getChatRequestBody(request *types.ChatCompletionRequest) *AliChatRequest {
+	messages := make([]AliMessage, 0, len(request.Messages))
+	for i := 0; i < len(request.Messages); i++ {
+		message := request.Messages[i]
+		messages = append(messages, AliMessage{
+			Content: message.StringContent(),
+			Role:    strings.ToLower(message.Role),
+		})
+	}
+
+	enableSearch := false
+	aliModel := request.Model
+	if strings.HasSuffix(aliModel, AliEnableSearchModelSuffix) {
+		enableSearch = true
+		aliModel = strings.TrimSuffix(aliModel, AliEnableSearchModelSuffix)
+	}
+
+	return &AliChatRequest{
+		Model: aliModel,
+		Input: AliInput{
+			Messages: messages,
+		},
+		Parameters: AliParameters{
+			EnableSearch:      enableSearch,
+			IncrementalOutput: request.Stream,
+		},
+	}
+}
+
+// 聊天
+func (p *AliProvider) ChatAction(request *types.ChatCompletionRequest, isModelMapped bool, promptTokens int) (usage *types.Usage, errWithCode *types.OpenAIErrorWithStatusCode) {
+
+	requestBody := p.getChatRequestBody(request)
+	fullRequestURL := p.GetFullRequestURL(p.ChatCompletions, request.Model)
+	headers := p.GetRequestHeaders()
+	if request.Stream {
+		headers["Accept"] = "text/event-stream"
+		headers["X-DashScope-SSE"] = "enable"
+	}
+
+	client := common.NewClient()
+	req, err := client.NewRequest(p.Context.Request.Method, fullRequestURL, common.WithBody(requestBody), common.WithHeader(headers))
+	if err != nil {
+		return nil, common.ErrorWrapper(err, "new_request_failed", http.StatusInternalServerError)
+	}
+
+	if request.Stream {
+		usage, errWithCode = p.sendStreamRequest(req, request.Model)
+		if errWithCode != nil {
+			return
+		}
+
+		if usage == nil {
+			usage = &types.Usage{
+				PromptTokens:     0,
+				CompletionTokens: 0,
+				TotalTokens:      0,
+			}
+		}
+
+	} else {
+		aliResponse := &AliChatResponse{
+			Model: request.Model,
+		}
+		errWithCode = p.SendRequest(req, aliResponse, false)
+		if errWithCode != nil {
+			return
+		}
+
+		usage = &types.Usage{
+			PromptTokens:     aliResponse.Usage.InputTokens,
+			CompletionTokens: aliResponse.Usage.OutputTokens,
+			TotalTokens:      aliResponse.Usage.InputTokens + aliResponse.Usage.OutputTokens,
+		}
+	}
+	return
+}
+
+// 阿里云响应转OpenAI响应
+func (p *AliProvider) streamResponseAli2OpenAI(aliResponse *AliChatResponse) *types.ChatCompletionStreamResponse {
+	var choice types.ChatCompletionStreamChoice
+	choice.Delta.Content = aliResponse.Output.Text
+	if aliResponse.Output.FinishReason != "null" {
+		finishReason := aliResponse.Output.FinishReason
+		choice.FinishReason = &finishReason
+	}
+
+	response := types.ChatCompletionStreamResponse{
+		ID:      aliResponse.RequestId,
+		Object:  "chat.completion.chunk",
+		Created: common.GetTimestamp(),
+		Model:   aliResponse.Model,
+		Choices: []types.ChatCompletionStreamChoice{choice},
+	}
+	return &response
+}
+
+// 发送流请求
+func (p *AliProvider) sendStreamRequest(req *http.Request, model string) (usage *types.Usage, errWithCode *types.OpenAIErrorWithStatusCode) {
+	defer req.Body.Close()
+
+	usage = &types.Usage{}
+	// 发送请求
+	client := common.GetHttpClient(p.Channel.Proxy)
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, common.ErrorWrapper(err, "http_request_failed", http.StatusInternalServerError)
+	}
+	common.PutHttpClient(client)
+
+	if common.IsFailureStatusCode(resp) {
+		return nil, common.HandleErrorResp(resp)
+	}
+
+	defer resp.Body.Close()
+
+	scanner := bufio.NewScanner(resp.Body)
+	scanner.Split(func(data []byte, atEOF bool) (advance int, token []byte, err error) {
+		if atEOF && len(data) == 0 {
+			return 0, nil, nil
+		}
+		if i := strings.Index(string(data), "\n"); i >= 0 {
+			return i + 1, data[0:i], nil
+		}
+		if atEOF {
+			return len(data), data, nil
+		}
+		return 0, nil, nil
+	})
+	dataChan := make(chan string)
+	stopChan := make(chan bool)
+	go func() {
+		for scanner.Scan() {
+			data := scanner.Text()
+			if len(data) < 5 { // ignore blank line or wrong format
+				continue
+			}
+			if data[:5] != "data:" {
+				continue
+			}
+			data = data[5:]
+			dataChan <- data
+		}
+		stopChan <- true
+	}()
+	common.SetEventStreamHeaders(p.Context)
+	// lastResponseText := ""
+	p.Context.Stream(func(w io.Writer) bool {
+		select {
+		case data := <-dataChan:
+			var aliResponse AliChatResponse
+			err := json.Unmarshal([]byte(data), &aliResponse)
+			if err != nil {
+				common.SysError("error unmarshalling stream response: " + err.Error())
+				return true
+			}
+			if aliResponse.Usage.OutputTokens != 0 {
+				usage.PromptTokens = aliResponse.Usage.InputTokens
+				usage.CompletionTokens = aliResponse.Usage.OutputTokens
+				usage.TotalTokens = aliResponse.Usage.InputTokens + aliResponse.Usage.OutputTokens
+			}
+			aliResponse.Model = model
+			response := p.streamResponseAli2OpenAI(&aliResponse)
+			// response.Choices[0].Delta.Content = strings.TrimPrefix(response.Choices[0].Delta.Content, lastResponseText)
+			// lastResponseText = aliResponse.Output.Text
+			jsonResponse, err := json.Marshal(response)
+			if err != nil {
+				common.SysError("error marshalling stream response: " + err.Error())
+				return true
+			}
+			p.Context.Render(-1, common.CustomEvent{Data: "data: " + string(jsonResponse)})
+			return true
+		case <-stopChan:
+			p.Context.Render(-1, common.CustomEvent{Data: "data: [DONE]"})
+			return false
+		}
+	})
+
+	return
+}

providers/ali/embeddings.go

@@ -0,0 +1,73 @@
+package ali
+
+import (
+	"net/http"
+	"one-api/common"
+	"one-api/types"
+)
+
+// 嵌入请求处理
+func (aliResponse *AliEmbeddingResponse) ResponseHandler(resp *http.Response) (any, *types.OpenAIErrorWithStatusCode) {
+	if aliResponse.Code != "" {
+		return nil, &types.OpenAIErrorWithStatusCode{
+			OpenAIError: types.OpenAIError{
+				Message: aliResponse.Message,
+				Type:    aliResponse.Code,
+				Param:   aliResponse.RequestId,
+				Code:    aliResponse.Code,
+			},
+			StatusCode: resp.StatusCode,
+		}
+	}
+
+	openAIEmbeddingResponse := &types.EmbeddingResponse{
+		Object: "list",
+		Data:   make([]types.Embedding, 0, len(aliResponse.Output.Embeddings)),
+		Model:  "text-embedding-v1",
+		Usage:  &types.Usage{TotalTokens: aliResponse.Usage.TotalTokens},
+	}
+
+	for _, item := range aliResponse.Output.Embeddings {
+		openAIEmbeddingResponse.Data = append(openAIEmbeddingResponse.Data, types.Embedding{
+			Object:    `embedding`,
+			Index:     item.TextIndex,
+			Embedding: item.Embedding,
+		})
+	}
+
+	return openAIEmbeddingResponse, nil
+}
+
+// 获取嵌入请求体
+func (p *AliProvider) getEmbeddingsRequestBody(request *types.EmbeddingRequest) *AliEmbeddingRequest {
+	return &AliEmbeddingRequest{
+		Model: "text-embedding-v1",
+		Input: struct {
+			Texts []string `json:"texts"`
+		}{
+			Texts: request.ParseInput(),
+		},
+	}
+}
+
+func (p *AliProvider) EmbeddingsAction(request *types.EmbeddingRequest, isModelMapped bool, promptTokens int) (usage *types.Usage, errWithCode *types.OpenAIErrorWithStatusCode) {
+
+	requestBody := p.getEmbeddingsRequestBody(request)
+	fullRequestURL := p.GetFullRequestURL(p.Embeddings, request.Model)
+	headers := p.GetRequestHeaders()
+
+	client := common.NewClient()
+	req, err := client.NewRequest(p.Context.Request.Method, fullRequestURL, common.WithBody(requestBody), common.WithHeader(headers))
+	if err != nil {
+		return nil, common.ErrorWrapper(err, "new_request_failed", http.StatusInternalServerError)
+	}
+
+	aliEmbeddingResponse := &AliEmbeddingResponse{}
+	errWithCode = p.SendRequest(req, aliEmbeddingResponse, false)
+	if errWithCode != nil {
+		return
+	}
+	usage = &types.Usage{TotalTokens: aliEmbeddingResponse.Usage.TotalTokens}
+
+	return usage, nil
+}

providers/ali/type.go

@@ -0,0 +1,72 @@
+package ali
+
+type AliError struct {
+	Code      string `json:"code"`
+	Message   string `json:"message"`
+	RequestId string `json:"request_id"`
+}
+
+type AliUsage struct {
+	InputTokens  int `json:"input_tokens"`
+	OutputTokens int `json:"output_tokens"`
+	TotalTokens  int `json:"total_tokens"`
+}
+
+type AliMessage struct {
+	Content string `json:"content"`
+	Role    string `json:"role"`
+}
+
+type AliInput struct {
+	// Prompt  string       `json:"prompt"`
+	Messages []AliMessage `json:"messages"`
+}
+
+type AliParameters struct {
+	TopP              float64 `json:"top_p,omitempty"`
+	TopK              int     `json:"top_k,omitempty"`
+	Seed              uint64  `json:"seed,omitempty"`
+	EnableSearch      bool    `json:"enable_search,omitempty"`
+	IncrementalOutput bool    `json:"incremental_output,omitempty"`
+}
+
+type AliChatRequest struct {
+	Model      string        `json:"model"`
+	Input      AliInput      `json:"input"`
+	Parameters AliParameters `json:"parameters,omitempty"`
+}
+
+type AliOutput struct {
+	Text         string `json:"text"`
+	FinishReason string `json:"finish_reason"`
+}
+
+type AliChatResponse struct {
+	Output AliOutput `json:"output"`
+	Usage  AliUsage  `json:"usage"`
+	Model  string    `json:"model,omitempty"`
+	AliError
+}
+
+type AliEmbeddingRequest struct {
+	Model string `json:"model"`
+	Input struct {
+		Texts []string `json:"texts"`
+	} `json:"input"`
+	Parameters *struct {
+		TextType string `json:"text_type,omitempty"`
+	} `json:"parameters,omitempty"`
+}
+
+type AliEmbedding struct {
+	Embedding []float64 `json:"embedding"`
+	TextIndex int       `json:"text_index"`
+}
+
+type AliEmbeddingResponse struct {
+	Output struct {
+		Embeddings []AliEmbedding `json:"embeddings"`
+	} `json:"output"`
+	Usage AliUsage `json:"usage"`
+	AliError
+}

providers/api2d/balance.go

@@ -0,0 +1,30 @@
+package api2d
+
+import (
+	"errors"
+	"one-api/common"
+	"one-api/model"
+	"one-api/providers/base"
+)
+
+func (p *Api2dProvider) Balance(channel *model.Channel) (float64, error) {
+	fullRequestURL := p.GetFullRequestURL("/dashboard/billing/credit_grants", "")
+	headers := p.GetRequestHeaders()
+
+	client := common.NewClient()
+	req, err := client.NewRequest("GET", fullRequestURL, common.WithHeader(headers))
+	if err != nil {
+		return 0, err
+	}
+
+	// 发送请求
+	var response base.BalanceResponse
+	_, errWithCode := common.SendRequest(req, &response, false, p.Channel.Proxy)
+	if errWithCode != nil {
+		return 0, errors.New(errWithCode.OpenAIError.Message)
+	}
+
+	channel.UpdateBalance(response.TotalAvailable)
+
+	return response.TotalAvailable, nil
+}

providers/api2d/base.go

@@ -0,0 +1,21 @@
+package api2d
+
+import (
+	"one-api/providers/base"
+	"one-api/providers/openai"
+
+	"github.com/gin-gonic/gin"
+)
+
+type Api2dProviderFactory struct{}
+
+// 创建 Api2dProvider
+func (f Api2dProviderFactory) Create(c *gin.Context) base.ProviderInterface {
+	return &Api2dProvider{
+		OpenAIProvider: openai.CreateOpenAIProvider(c, "https://oa.api2d.net"),
+	}
+}
+
+type Api2dProvider struct {
+	*openai.OpenAIProvider
+}

providers/api2gpt/balance.go

@@ -0,0 +1,30 @@
+package api2gpt
+
+import (
+	"errors"
+	"one-api/common"
+	"one-api/model"
+	"one-api/providers/base"
+)
+
+func (p *Api2gptProvider) Balance(channel *model.Channel) (float64, error) {
+	fullRequestURL := p.GetFullRequestURL("/dashboard/billing/credit_grants", "")
+	headers := p.GetRequestHeaders()
+
+	client := common.NewClient()
+	req, err := client.NewRequest("GET", fullRequestURL, common.WithHeader(headers))
+	if err != nil {
+		return 0, err
+	}
+
+	// 发送请求
+	var response base.BalanceResponse
+	_, errWithCode := common.SendRequest(req, &response, false, p.Channel.Proxy)
+	if errWithCode != nil {
+		return 0, errors.New(errWithCode.OpenAIError.Message)
+	}
+
+	channel.UpdateBalance(response.TotalAvailable)
+
+	return response.TotalRemaining, nil
+}

providers/api2gpt/base.go

@@ -0,0 +1,20 @@
+package api2gpt
+
+import (
+	"one-api/providers/base"
+	"one-api/providers/openai"
+
+	"github.com/gin-gonic/gin"
+)
+
+type Api2gptProviderFactory struct{}
+
+func (f Api2gptProviderFactory) Create(c *gin.Context) base.ProviderInterface {
+	return &Api2gptProvider{
+		OpenAIProvider: openai.CreateOpenAIProvider(c, "https://api.api2gpt.com"),
+	}
+}
+
+type Api2gptProvider struct {
+	*openai.OpenAIProvider
+}

providers/azure/base.go

@@ -0,0 +1,36 @@
+package azure
+
+import (
+	"one-api/providers/base"
+	"one-api/providers/openai"
+
+	"github.com/gin-gonic/gin"
+)
+
+type AzureProviderFactory struct{}
+
+// 创建 AzureProvider
+func (f AzureProviderFactory) Create(c *gin.Context) base.ProviderInterface {
+	return &AzureProvider{
+		OpenAIProvider: openai.OpenAIProvider{
+			BaseProvider: base.BaseProvider{
+				BaseURL:             "",
+				Completions:         "/completions",
+				ChatCompletions:     "/chat/completions",
+				Embeddings:          "/embeddings",
+				AudioTranscriptions: "/audio/transcriptions",
+				AudioTranslations:   "/audio/translations",
+				ImagesGenerations:   "/images/generations",
+				// ImagesEdit:          "/images/edit",
+				// ImagesVariations:    "/images/variations",
+				Context: c,
+				// AudioSpeech:         "/audio/speech",
+			},
+			IsAzure: true,
+		},
+	}
+}
+
+type AzureProvider struct {
+	openai.OpenAIProvider
+}

providers/azure/image_generations.go

@@ -0,0 +1,103 @@
+package azure
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"one-api/common"
+	"one-api/providers/openai"
+	"one-api/types"
+	"time"
+)
+
+func (c *ImageAzureResponse) ResponseHandler(resp *http.Response) (OpenAIResponse any, errWithCode *types.OpenAIErrorWithStatusCode) {
+	if c.Status == "canceled" || c.Status == "failed" {
+		errWithCode = &types.OpenAIErrorWithStatusCode{
+			OpenAIError: types.OpenAIError{
+				Message: c.Error.Message,
+				Type:    "one_api_error",
+				Code:    c.Error.Code,
+			},
+			StatusCode: resp.StatusCode,
+		}
+		return
+	}
+
+	operation_location := resp.Header.Get("operation-location")
+	if operation_location == "" {
+		return nil, common.ErrorWrapper(errors.New("image url is empty"), "get_images_url_failed", http.StatusInternalServerError)
+	}
+
+	client := common.NewClient()
+	req, err := client.NewRequest("GET", operation_location, common.WithHeader(c.Header))
+	if err != nil {
+		return nil, common.ErrorWrapper(err, "get_images_request_failed", http.StatusInternalServerError)
+	}
+
+	getImageAzureResponse := ImageAzureResponse{}
+	for i := 0; i < 3; i++ {
+		// 休眠 2 秒
+		time.Sleep(2 * time.Second)
+		_, errWithCode = common.SendRequest(req, &getImageAzureResponse, false, c.Proxy)
+		fmt.Println("getImageAzureResponse", getImageAzureResponse)
+		if errWithCode != nil {
+			return
+		}
+
+		if getImageAzureResponse.Status == "canceled" || getImageAzureResponse.Status == "failed" {
+			return nil, &types.OpenAIErrorWithStatusCode{
+				OpenAIError: types.OpenAIError{
+					Message: c.Error.Message,
+					Type:    "get_images_request_failed",
+					Code:    c.Error.Code,
+				},
+				StatusCode: resp.StatusCode,
+			}
+		}
+		if getImageAzureResponse.Status == "succeeded" {
+			return getImageAzureResponse.Result, nil
+		}
+	}
+
+	return nil, common.ErrorWrapper(errors.New("get image Timeout"), "get_images_url_failed", http.StatusInternalServerError)
+}
+
+func (p *AzureProvider) ImageGenerationsAction(request *types.ImageRequest, isModelMapped bool, promptTokens int) (usage *types.Usage, errWithCode *types.OpenAIErrorWithStatusCode) {
+
+	requestBody, err := p.GetRequestBody(&request, isModelMapped)
+	if err != nil {
+		return nil, common.ErrorWrapper(err, "json_marshal_failed", http.StatusInternalServerError)
+	}
+
+	fullRequestURL := p.GetFullRequestURL(p.ImagesGenerations, request.Model)
+	headers := p.GetRequestHeaders()
+
+	client := common.NewClient()
+	req, err := client.NewRequest(p.Context.Request.Method, fullRequestURL, common.WithBody(requestBody), common.WithHeader(headers))
+	if err != nil {
+		return nil, common.ErrorWrapper(err, "new_request_failed", http.StatusInternalServerError)
+	}
+
+	if request.Model == "dall-e-2" {
+		imageAzureResponse := &ImageAzureResponse{
+			Header: headers,
+			Proxy:  p.Channel.Proxy,
+		}
+		errWithCode = p.SendRequest(req, imageAzureResponse, false)
+	} else {
+		openAIProviderImageResponseResponse := &openai.OpenAIProviderImageResponseResponse{}
+		errWithCode = p.SendRequest(req, openAIProviderImageResponseResponse, true)
+	}
+
+	if errWithCode != nil {
+		return
+	}
+
+	usage = &types.Usage{
+		PromptTokens:     promptTokens,
+		CompletionTokens: 0,
+		TotalTokens:      promptTokens,
+	}
+
+	return
+}

providers/azure/type.go

@@ -0,0 +1,22 @@
+package azure
+
+import "one-api/types"
+
+type ImageAzureResponse struct {
+	ID      string              `json:"id,omitempty"`
+	Created int64               `json:"created,omitempty"`
+	Expires int64               `json:"expires,omitempty"`
+	Result  types.ImageResponse `json:"result,omitempty"`
+	Status  string              `json:"status,omitempty"`
+	Error   ImageAzureError     `json:"error,omitempty"`
+	Header  map[string]string   `json:"header,omitempty"`
+	Proxy   string              `json:"proxy,omitempty"`
+}
+
+type ImageAzureError struct {
+	Code       string   `json:"code,omitempty"`
+	Target     string   `json:"target,omitempty"`
+	Message    string   `json:"message,omitempty"`
+	Details    []string `json:"details,omitempty"`
+	InnerError any      `json:"innererror,omitempty"`
+}

providers/azureSpeech/base.go

@@ -0,0 +1,36 @@
+package azureSpeech
+
+import (
+	"one-api/providers/base"
+
+	"github.com/gin-gonic/gin"
+)
+
+// 定义供应商工厂
+type AzureSpeechProviderFactory struct{}
+
+// 创建 AliProvider
+func (f AzureSpeechProviderFactory) Create(c *gin.Context) base.ProviderInterface {
+	return &AzureSpeechProvider{
+		BaseProvider: base.BaseProvider{
+			BaseURL:     "",
+			AudioSpeech: "/cognitiveservices/v1",
+			Context:     c,
+		},
+	}
+}
+
+type AzureSpeechProvider struct {
+	base.BaseProvider
+}
+
+// 获取请求头
+func (p *AzureSpeechProvider) GetRequestHeaders() (headers map[string]string) {
+	headers = make(map[string]string)
+	headers["Ocp-Apim-Subscription-Key"] = p.Channel.Key
+	headers["Content-Type"] = "application/ssml+xml"
+	headers["User-Agent"] = "OneAPI"
+	// headers["X-Microsoft-OutputFormat"] = "audio-16khz-128kbitrate-mono-mp3"
+
+	return headers
+}

providers/azureSpeech/speech.go

@@ -0,0 +1,88 @@
+package azureSpeech
+
+import (
+	"bytes"
+	"fmt"
+	"net/http"
+	"one-api/common"
+	"one-api/types"
+)
+
+var outputFormatMap = map[string]string{
+	"mp3":  "audio-16khz-128kbitrate-mono-mp3",
+	"opus": "audio-16khz-128kbitrate-mono-opus",
+	"aac":  "audio-24khz-160kbitrate-mono-mp3",
+	"flac": "audio-48khz-192kbitrate-mono-mp3",
+}
+
+func CreateSSML(text string, name string, role string) string {
+	ssmlTemplate := `<speak version='1.0' xml:lang='en-US'>
+        <voice xml:lang='en-US' %s name='%s'>
+            %s
+        </voice>
+    </speak>`
+
+	roleAttribute := ""
+	if role != "" {
+		roleAttribute = fmt.Sprintf("role='%s'", role)
+	}
+
+	return fmt.Sprintf(ssmlTemplate, roleAttribute, name, text)
+}
+
+func (p *AzureSpeechProvider) getRequestBody(request *types.SpeechAudioRequest) *bytes.Buffer {
+	voiceMap := map[string][]string{
+		"alloy":   {"zh-CN-YunxiNeural"},
+		"echo":    {"zh-CN-YunyangNeural"},
+		"fable":   {"zh-CN-YunxiNeural", "Boy"},
+		"onyx":    {"zh-CN-YunyeNeural"},
+		"nova":    {"zh-CN-XiaochenNeural"},
+		"shimmer": {"zh-CN-XiaohanNeural"},
+	}
+
+	voice := ""
+	role := ""
+	if voiceMap[request.Voice] != nil {
+		voice = voiceMap[request.Voice][0]
+		if len(voiceMap[request.Voice]) > 1 {
+			role = voiceMap[request.Voice][1]
+		}
+	}
+
+	ssml := CreateSSML(request.Input, voice, role)
+
+	return bytes.NewBufferString(ssml)
+
+}
+
+func (p *AzureSpeechProvider) SpeechAction(request *types.SpeechAudioRequest, isModelMapped bool, promptTokens int) (usage *types.Usage, errWithCode *types.OpenAIErrorWithStatusCode) {
+
+	fullRequestURL := p.GetFullRequestURL(p.AudioSpeech, request.Model)
+	headers := p.GetRequestHeaders()
+	responseFormatr := outputFormatMap[request.ResponseFormat]
+	if responseFormatr == "" {
+		responseFormatr = outputFormatMap["mp3"]
+	}
+	headers["X-Microsoft-OutputFormat"] = responseFormatr
+
+	requestBody := p.getRequestBody(request)
+
+	client := common.NewClient()
+	req, err := client.NewRequest(p.Context.Request.Method, fullRequestURL, common.WithBody(requestBody), common.WithHeader(headers))
+	if err != nil {
+		return nil, common.ErrorWrapper(err, "new_request_failed", http.StatusInternalServerError)
+	}
+
+	errWithCode = p.SendRequestRaw(req)
+	if errWithCode != nil {
+		return
+	}
+
+	usage = &types.Usage{
+		PromptTokens:     promptTokens,
+		CompletionTokens: 0,
+		TotalTokens:      promptTokens,
+	}
+
+	return
+}

providers/baidu/base.go

@@ -0,0 +1,131 @@
+package baidu
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"one-api/common"
+	"one-api/providers/base"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/gin-gonic/gin"
+)
+
+// 定义供应商工厂
+type BaiduProviderFactory struct{}
+
+// 创建 BaiduProvider
+
+func (f BaiduProviderFactory) Create(c *gin.Context) base.ProviderInterface {
+	return &BaiduProvider{
+		BaseProvider: base.BaseProvider{
+			BaseURL:         "https://aip.baidubce.com",
+			ChatCompletions: "/rpc/2.0/ai_custom/v1/wenxinworkshop/chat",
+			Embeddings:      "/rpc/2.0/ai_custom/v1/wenxinworkshop/embeddings",
+			Context:         c,
+		},
+	}
+}
+
+var baiduTokenStore sync.Map
+
+type BaiduProvider struct {
+	base.BaseProvider
+}
+
+// 获取完整请求 URL
+func (p *BaiduProvider) GetFullRequestURL(requestURL string, modelName string) string {
+	var modelNameMap = map[string]string{
+		"ERNIE-Bot":       "completions",
+		"ERNIE-Bot-turbo": "eb-instant",
+		"ERNIE-Bot-4":     "completions_pro",
+		"BLOOMZ-7B":       "bloomz_7b1",
+		"Embedding-V1":    "embedding-v1",
+	}
+
+	baseURL := strings.TrimSuffix(p.GetBaseURL(), "/")
+	apiKey, err := p.getBaiduAccessToken()
+	if err != nil {
+		return ""
+	}
+
+	return fmt.Sprintf("%s%s/%s?access_token=%s", baseURL, requestURL, modelNameMap[modelName], apiKey)
+}
+
+// 获取请求头
+func (p *BaiduProvider) GetRequestHeaders() (headers map[string]string) {
+	headers = make(map[string]string)
+	p.CommonRequestHeaders(headers)
+
+	return headers
+}
+
+func (p *BaiduProvider) getBaiduAccessToken() (string, error) {
+	apiKey := p.Channel.Key
+	if val, ok := baiduTokenStore.Load(apiKey); ok {
+		var accessToken BaiduAccessToken
+		if accessToken, ok = val.(BaiduAccessToken); ok {
+			// soon this will expire
+			if time.Now().Add(time.Hour).After(accessToken.ExpiresAt) {
+				go func() {
+					_, _ = p.getBaiduAccessTokenHelper(apiKey)
+				}()
+			}
+			return accessToken.AccessToken, nil
+		}
+	}
+	accessToken, err := p.getBaiduAccessTokenHelper(apiKey)
+	if err != nil {
+		return "", err
+	}
+	if accessToken == nil {
+		return "", errors.New("getBaiduAccessToken return a nil token")
+	}
+	return (*accessToken).AccessToken, nil
+}
+
+func (p *BaiduProvider) getBaiduAccessTokenHelper(apiKey string) (*BaiduAccessToken, error) {
+	parts := strings.Split(apiKey, "|")
+	if len(parts) != 2 {
+		return nil, errors.New("invalid baidu apikey")
+	}
+
+	client := common.NewClient()
+	url := fmt.Sprintf(p.BaseURL+"/oauth/2.0/token?grant_type=client_credentials&client_id=%s&client_secret=%s", parts[0], parts[1])
+
+	var headers = map[string]string{
+		"Content-Type": "application/json",
+		"Accept":       "application/json",
+	}
+
+	req, err := client.NewRequest("POST", url, common.WithHeader(headers))
+	if err != nil {
+		return nil, err
+	}
+
+	httpClient := common.GetHttpClient(p.Channel.Proxy)
+	resp, err := httpClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	common.PutHttpClient(httpClient)
+
+	defer resp.Body.Close()
+
+	var accessToken BaiduAccessToken
+	err = json.NewDecoder(resp.Body).Decode(&accessToken)
+	if err != nil {
+		return nil, err
+	}
+	if accessToken.Error != "" {
+		return nil, errors.New(accessToken.Error + ": " + accessToken.ErrorDescription)
+	}
+	if accessToken.AccessToken == "" {
+		return nil, errors.New("getBaiduAccessTokenHelper get empty access token")
+	}
+	accessToken.ExpiresAt = time.Now().Add(time.Duration(accessToken.ExpiresIn) * time.Second)
+	baiduTokenStore.Store(apiKey, accessToken)
+	return &accessToken, nil
+}

providers/baidu/chat.go

@@ -0,0 +1,203 @@
+package baidu
+
+import (
+	"bufio"
+	"encoding/json"
+	"io"
+	"net/http"
+	"one-api/common"
+	"one-api/providers/base"
+	"one-api/types"
+	"strings"
+)
+
+func (baiduResponse *BaiduChatResponse) ResponseHandler(resp *http.Response) (OpenAIResponse any, errWithCode *types.OpenAIErrorWithStatusCode) {
+	if baiduResponse.ErrorMsg != "" {
+		return nil, &types.OpenAIErrorWithStatusCode{
+			OpenAIError: types.OpenAIError{
+				Message: baiduResponse.ErrorMsg,
+				Type:    "baidu_error",
+				Param:   "",
+				Code:    baiduResponse.ErrorCode,
+			},
+			StatusCode: resp.StatusCode,
+		}
+	}
+
+	choice := types.ChatCompletionChoice{
+		Index: 0,
+		Message: types.ChatCompletionMessage{
+			Role:    "assistant",
+			Content: baiduResponse.Result,
+		},
+		FinishReason: "stop",
+	}
+
+	OpenAIResponse = types.ChatCompletionResponse{
+		ID:      baiduResponse.Id,
+		Object:  "chat.completion",
+		Created: baiduResponse.Created,
+		Choices: []types.ChatCompletionChoice{choice},
+		Usage:   baiduResponse.Usage,
+	}
+
+	return
+}
+
+func (p *BaiduProvider) getChatRequestBody(request *types.ChatCompletionRequest) *BaiduChatRequest {
+	messages := make([]BaiduMessage, 0, len(request.Messages))
+	for _, message := range request.Messages {
+		if message.Role == "system" {
+			messages = append(messages, BaiduMessage{
+				Role:    "user",
+				Content: message.StringContent(),
+			})
+			messages = append(messages, BaiduMessage{
+				Role:    "assistant",
+				Content: "Okay",
+			})
+		} else {
+			messages = append(messages, BaiduMessage{
+				Role:    message.Role,
+				Content: message.StringContent(),
+			})
+		}
+	}
+	return &BaiduChatRequest{
+		Messages: messages,
+		Stream:   request.Stream,
+	}
+}
+
+func (p *BaiduProvider) ChatAction(request *types.ChatCompletionRequest, isModelMapped bool, promptTokens int) (usage *types.Usage, errWithCode *types.OpenAIErrorWithStatusCode) {
+	requestBody := p.getChatRequestBody(request)
+	fullRequestURL := p.GetFullRequestURL(p.ChatCompletions, request.Model)
+	if fullRequestURL == "" {
+		return nil, common.ErrorWrapper(nil, "invalid_baidu_config", http.StatusInternalServerError)
+	}
+
+	headers := p.GetRequestHeaders()
+	if request.Stream {
+		headers["Accept"] = "text/event-stream"
+	}
+
+	client := common.NewClient()
+	req, err := client.NewRequest(p.Context.Request.Method, fullRequestURL, common.WithBody(requestBody), common.WithHeader(headers))
+	if err != nil {
+		return nil, common.ErrorWrapper(err, "new_request_failed", http.StatusInternalServerError)
+	}
+
+	if request.Stream {
+		usage, errWithCode = p.sendStreamRequest(req, request.Model)
+		if errWithCode != nil {
+			return
+		}
+
+	} else {
+		baiduChatRequest := &BaiduChatResponse{
+			Model: request.Model,
+		}
+		errWithCode = p.SendRequest(req, baiduChatRequest, false)
+		if errWithCode != nil {
+			return
+		}
+
+		usage = baiduChatRequest.Usage
+	}
+	return
+
+}
+
+func (p *BaiduProvider) streamResponseBaidu2OpenAI(baiduResponse *BaiduChatStreamResponse) *types.ChatCompletionStreamResponse {
+	var choice types.ChatCompletionStreamChoice
+	choice.Delta.Content = baiduResponse.Result
+	if baiduResponse.IsEnd {
+		choice.FinishReason = &base.StopFinishReason
+	}
+
+	response := types.ChatCompletionStreamResponse{
+		ID:      baiduResponse.Id,
+		Object:  "chat.completion.chunk",
+		Created: baiduResponse.Created,
+		Model:   baiduResponse.Model,
+		Choices: []types.ChatCompletionStreamChoice{choice},
+	}
+	return &response
+}
+
+func (p *BaiduProvider) sendStreamRequest(req *http.Request, model string) (usage *types.Usage, errWithCode *types.OpenAIErrorWithStatusCode) {
+	defer req.Body.Close()
+
+	usage = &types.Usage{}
+	// 发送请求
+	client := common.GetHttpClient(p.Channel.Proxy)
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, common.ErrorWrapper(err, "http_request_failed", http.StatusInternalServerError)
+	}
+	common.PutHttpClient(client)
+
+	if common.IsFailureStatusCode(resp) {
+		return nil, common.HandleErrorResp(resp)
+	}
+
+	defer resp.Body.Close()
+
+	scanner := bufio.NewScanner(resp.Body)
+	scanner.Split(func(data []byte, atEOF bool) (advance int, token []byte, err error) {
+		if atEOF && len(data) == 0 {
+			return 0, nil, nil
+		}
+		if i := strings.Index(string(data), "\n"); i >= 0 {
+			return i + 1, data[0:i], nil
+		}
+		if atEOF {
+			return len(data), data, nil
+		}
+		return 0, nil, nil
+	})
+	dataChan := make(chan string)
+	stopChan := make(chan bool)
+	go func() {
+		for scanner.Scan() {
+			data := scanner.Text()
+			if len(data) < 6 { // ignore blank line or wrong format
+				continue
+			}
+			data = data[6:]
+			dataChan <- data
+		}
+		stopChan <- true
+	}()
+	common.SetEventStreamHeaders(p.Context)
+	p.Context.Stream(func(w io.Writer) bool {
+		select {
+		case data := <-dataChan:
+			var baiduResponse BaiduChatStreamResponse
+			err := json.Unmarshal([]byte(data), &baiduResponse)
+			if err != nil {
+				common.SysError("error unmarshalling stream response: " + err.Error())
+				return true
+			}
+			if baiduResponse.Usage.TotalTokens != 0 {
+				usage.TotalTokens = baiduResponse.Usage.TotalTokens
+				usage.PromptTokens = baiduResponse.Usage.PromptTokens
+				usage.CompletionTokens = baiduResponse.Usage.TotalTokens - baiduResponse.Usage.PromptTokens
+			}
+			baiduResponse.Model = model
+			response := p.streamResponseBaidu2OpenAI(&baiduResponse)
+			jsonResponse, err := json.Marshal(response)
+			if err != nil {
+				common.SysError("error marshalling stream response: " + err.Error())
+				return true
+			}
+			p.Context.Render(-1, common.CustomEvent{Data: "data: " + string(jsonResponse)})
+			return true
+		case <-stopChan:
+			p.Context.Render(-1, common.CustomEvent{Data: "data: [DONE]"})
+			return false
+		}
+	})
+
+	return usage, nil
+}

providers/baidu/embeddings.go

@@ -0,0 +1,69 @@
+package baidu
+
+import (
+	"net/http"
+	"one-api/common"
+	"one-api/types"
+)
+
+func (p *BaiduProvider) getEmbeddingsRequestBody(request *types.EmbeddingRequest) *BaiduEmbeddingRequest {
+	return &BaiduEmbeddingRequest{
+		Input: request.ParseInput(),
+	}
+}
+
+func (baiduResponse *BaiduEmbeddingResponse) ResponseHandler(resp *http.Response) (OpenAIResponse any, errWithCode *types.OpenAIErrorWithStatusCode) {
+	if baiduResponse.ErrorMsg != "" {
+		return nil, &types.OpenAIErrorWithStatusCode{
+			OpenAIError: types.OpenAIError{
+				Message: baiduResponse.ErrorMsg,
+				Type:    "baidu_error",
+				Param:   "",
+				Code:    baiduResponse.ErrorCode,
+			},
+			StatusCode: resp.StatusCode,
+		}
+	}
+
+	openAIEmbeddingResponse := &types.EmbeddingResponse{
+		Object: "list",
+		Data:   make([]types.Embedding, 0, len(baiduResponse.Data)),
+		Model:  "text-embedding-v1",
+		Usage:  &baiduResponse.Usage,
+	}
+
+	for _, item := range baiduResponse.Data {
+		openAIEmbeddingResponse.Data = append(openAIEmbeddingResponse.Data, types.Embedding{
+			Object:    item.Object,
+			Index:     item.Index,
+			Embedding: item.Embedding,
+		})
+	}
+
+	return openAIEmbeddingResponse, nil
+}
+
+func (p *BaiduProvider) EmbeddingsAction(request *types.EmbeddingRequest, isModelMapped bool, promptTokens int) (usage *types.Usage, errWithCode *types.OpenAIErrorWithStatusCode) {
+
+	requestBody := p.getEmbeddingsRequestBody(request)
+	fullRequestURL := p.GetFullRequestURL(p.Embeddings, request.Model)
+	if fullRequestURL == "" {
+		return nil, common.ErrorWrapper(nil, "invalid_baidu_config", http.StatusInternalServerError)
+	}
+
+	headers := p.GetRequestHeaders()
+	client := common.NewClient()
+	req, err := client.NewRequest(p.Context.Request.Method, fullRequestURL, common.WithBody(requestBody), common.WithHeader(headers))
+	if err != nil {
+		return nil, common.ErrorWrapper(err, "new_request_failed", http.StatusInternalServerError)
+	}
+
+	baiduEmbeddingResponse := &BaiduEmbeddingResponse{}
+	errWithCode = p.SendRequest(req, baiduEmbeddingResponse, false)
+	if errWithCode != nil {
+		return
+	}
+	usage = &baiduEmbeddingResponse.Usage
+
+	return usage, nil
+}

providers/baidu/type.go

@@ -0,0 +1,67 @@
+package baidu
+
+import (
+	"one-api/types"
+	"time"
+)
+
+type BaiduAccessToken struct {
+	AccessToken      string    `json:"access_token"`
+	Error            string    `json:"error,omitempty"`
+	ErrorDescription string    `json:"error_description,omitempty"`
+	ExpiresIn        int64     `json:"expires_in,omitempty"`
+	ExpiresAt        time.Time `json:"-"`
+}
+
+type BaiduMessage struct {
+	Role    string `json:"role"`
+	Content string `json:"content"`
+}
+
+type BaiduChatRequest struct {
+	Messages []BaiduMessage `json:"messages"`
+	Stream   bool           `json:"stream"`
+	UserId   string         `json:"user_id,omitempty"`
+}
+
+type BaiduChatResponse struct {
+	Id               string       `json:"id"`
+	Object           string       `json:"object"`
+	Created          int64        `json:"created"`
+	Result           string       `json:"result"`
+	IsTruncated      bool         `json:"is_truncated"`
+	NeedClearHistory bool         `json:"need_clear_history"`
+	Usage            *types.Usage `json:"usage"`
+	Model            string       `json:"model,omitempty"`
+	BaiduError
+}
+
+type BaiduEmbeddingRequest struct {
+	Input []string `json:"input"`
+}
+
+type BaiduEmbeddingData struct {
+	Object    string    `json:"object"`
+	Embedding []float64 `json:"embedding"`
+	Index     int       `json:"index"`
+}
+
+type BaiduEmbeddingResponse struct {
+	Id      string               `json:"id"`
+	Object  string               `json:"object"`
+	Created int64                `json:"created"`
+	Data    []BaiduEmbeddingData `json:"data"`
+	Usage   types.Usage          `json:"usage"`
+	BaiduError
+}
+
+type BaiduChatStreamResponse struct {
+	BaiduChatResponse
+	SentenceId int  `json:"sentence_id"`
+	IsEnd      bool `json:"is_end"`
+}
+
+type BaiduError struct {
+	ErrorCode int    `json:"error_code"`
+	ErrorMsg  string `json:"error_msg"`
+}

providers/base/common.go

@@ -0,0 +1,164 @@
+package base
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"one-api/common"
+	"one-api/model"
+	"one-api/types"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+)
+
+var StopFinishReason = "stop"
+
+type BaseProvider struct {
+	BaseURL             string
+	Completions         string
+	ChatCompletions     string
+	Embeddings          string
+	AudioSpeech         string
+	Moderation          string
+	AudioTranscriptions string
+	AudioTranslations   string
+	ImagesGenerations   string
+	ImagesEdit          string
+	ImagesVariations    string
+	Proxy               string
+	Context             *gin.Context
+	Channel             *model.Channel
+}
+
+// 获取基础URL
+func (p *BaseProvider) GetBaseURL() string {
+	if p.Channel.GetBaseURL() != "" {
+		return p.Channel.GetBaseURL()
+	}
+
+	return p.BaseURL
+}
+
+func (p *BaseProvider) SetChannel(channel *model.Channel) {
+	p.Channel = channel
+}
+
+// 获取完整请求URL
+func (p *BaseProvider) GetFullRequestURL(requestURL string, modelName string) string {
+	baseURL := strings.TrimSuffix(p.GetBaseURL(), "/")
+
+	return fmt.Sprintf("%s%s", baseURL, requestURL)
+}
+
+// 获取请求头
+func (p *BaseProvider) CommonRequestHeaders(headers map[string]string) {
+	headers["Content-Type"] = p.Context.Request.Header.Get("Content-Type")
+	headers["Accept"] = p.Context.Request.Header.Get("Accept")
+	if headers["Content-Type"] == "" {
+		headers["Content-Type"] = "application/json"
+	}
+}
+
+// 发送请求
+func (p *BaseProvider) SendRequest(req *http.Request, response ProviderResponseHandler, rawOutput bool) (openAIErrorWithStatusCode *types.OpenAIErrorWithStatusCode) {
+	defer req.Body.Close()
+
+	resp, openAIErrorWithStatusCode := common.SendRequest(req, response, true, p.Channel.Proxy)
+	if openAIErrorWithStatusCode != nil {
+		return
+	}
+
+	defer resp.Body.Close()
+
+	openAIResponse, openAIErrorWithStatusCode := response.ResponseHandler(resp)
+	if openAIErrorWithStatusCode != nil {
+		return
+	}
+
+	if rawOutput {
+		for k, v := range resp.Header {
+			p.Context.Writer.Header().Set(k, v[0])
+		}
+
+		p.Context.Writer.WriteHeader(resp.StatusCode)
+		_, err := io.Copy(p.Context.Writer, resp.Body)
+		if err != nil {
+			return common.ErrorWrapper(err, "copy_response_body_failed", http.StatusInternalServerError)
+		}
+	} else {
+		jsonResponse, err := json.Marshal(openAIResponse)
+		if err != nil {
+			return common.ErrorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError)
+		}
+		p.Context.Writer.Header().Set("Content-Type", "application/json")
+		p.Context.Writer.WriteHeader(resp.StatusCode)
+		_, err = p.Context.Writer.Write(jsonResponse)
+
+		if err != nil {
+			return common.ErrorWrapper(err, "write_response_body_failed", http.StatusInternalServerError)
+		}
+	}
+
+	return nil
+}
+
+func (p *BaseProvider) SendRequestRaw(req *http.Request) (openAIErrorWithStatusCode *types.OpenAIErrorWithStatusCode) {
+	defer req.Body.Close()
+
+	// 发送请求
+	client := common.GetHttpClient(p.Channel.Proxy)
+	resp, err := client.Do(req)
+	if err != nil {
+		return common.ErrorWrapper(err, "http_request_failed", http.StatusInternalServerError)
+	}
+	common.PutHttpClient(client)
+
+	defer resp.Body.Close()
+
+	// 处理响应
+	if common.IsFailureStatusCode(resp) {
+		return common.HandleErrorResp(resp)
+	}
+
+	for k, v := range resp.Header {
+		p.Context.Writer.Header().Set(k, v[0])
+	}
+
+	p.Context.Writer.WriteHeader(resp.StatusCode)
+
+	_, err = io.Copy(p.Context.Writer, resp.Body)
+	if err != nil {
+		return common.ErrorWrapper(err, "write_response_body_failed", http.StatusInternalServerError)
+	}
+
+	return nil
+}
+
+func (p *BaseProvider) SupportAPI(relayMode int) bool {
+	switch relayMode {
+	case common.RelayModeChatCompletions:
+		return p.ChatCompletions != ""
+	case common.RelayModeCompletions:
+		return p.Completions != ""
+	case common.RelayModeEmbeddings:
+		return p.Embeddings != ""
+	case common.RelayModeAudioSpeech:
+		return p.AudioSpeech != ""
+	case common.RelayModeAudioTranscription:
+		return p.AudioTranscriptions != ""
+	case common.RelayModeAudioTranslation:
+		return p.AudioTranslations != ""
+	case common.RelayModeModerations:
+		return p.Moderation != ""
+	case common.RelayModeImagesGenerations:
+		return p.ImagesGenerations != ""
+	case common.RelayModeImagesEdits:
+		return p.ImagesEdit != ""
+	case common.RelayModeImagesVariations:
+		return p.ImagesVariations != ""
+	default:
+		return false
+	}
+}

providers/base/interface.go

@@ -0,0 +1,85 @@
+package base
+
+import (
+	"net/http"
+	"one-api/model"
+	"one-api/types"
+)
+
+// 基础接口
+type ProviderInterface interface {
+	GetBaseURL() string
+	GetFullRequestURL(requestURL string, modelName string) string
+	GetRequestHeaders() (headers map[string]string)
+	SupportAPI(relayMode int) bool
+	SetChannel(channel *model.Channel)
+}
+
+// 完成接口
+type CompletionInterface interface {
+	ProviderInterface
+	CompleteAction(request *types.CompletionRequest, isModelMapped bool, promptTokens int) (usage *types.Usage, errWithCode *types.OpenAIErrorWithStatusCode)
+}
+
+// 聊天接口
+type ChatInterface interface {
+	ProviderInterface
+	ChatAction(request *types.ChatCompletionRequest, isModelMapped bool, promptTokens int) (usage *types.Usage, errWithCode *types.OpenAIErrorWithStatusCode)
+}
+
+// 嵌入接口
+type EmbeddingsInterface interface {
+	ProviderInterface
+	EmbeddingsAction(request *types.EmbeddingRequest, isModelMapped bool, promptTokens int) (usage *types.Usage, errWithCode *types.OpenAIErrorWithStatusCode)
+}
+
+// 审查接口
+type ModerationInterface interface {
+	ProviderInterface
+	ModerationAction(request *types.ModerationRequest, isModelMapped bool, promptTokens int) (usage *types.Usage, errWithCode *types.OpenAIErrorWithStatusCode)
+}
+
+// 文字转语音接口
+type SpeechInterface interface {
+	ProviderInterface
+	SpeechAction(request *types.SpeechAudioRequest, isModelMapped bool, promptTokens int) (usage *types.Usage, errWithCode *types.OpenAIErrorWithStatusCode)
+}
+
+// 语音转文字接口
+type TranscriptionsInterface interface {
+	ProviderInterface
+	TranscriptionsAction(request *types.AudioRequest, isModelMapped bool, promptTokens int) (usage *types.Usage, errWithCode *types.OpenAIErrorWithStatusCode)
+}
+
+// 语音翻译接口
+type TranslationInterface interface {
+	ProviderInterface
+	TranslationAction(request *types.AudioRequest, isModelMapped bool, promptTokens int) (usage *types.Usage, errWithCode *types.OpenAIErrorWithStatusCode)
+}
+
+// 图片生成接口
+type ImageGenerationsInterface interface {
+	ProviderInterface
+	ImageGenerationsAction(request *types.ImageRequest, isModelMapped bool, promptTokens int) (usage *types.Usage, errWithCode *types.OpenAIErrorWithStatusCode)
+}
+
+// 图片编辑接口
+type ImageEditsInterface interface {
+	ProviderInterface
+	ImageEditsAction(request *types.ImageEditRequest, isModelMapped bool, promptTokens int) (usage *types.Usage, errWithCode *types.OpenAIErrorWithStatusCode)
+}
+
+type ImageVariationsInterface interface {
+	ProviderInterface
+	ImageVariationsAction(request *types.ImageEditRequest, isModelMapped bool, promptTokens int) (usage *types.Usage, errWithCode *types.OpenAIErrorWithStatusCode)
+}
+
+// 余额接口
+type BalanceInterface interface {
+	Balance(channel *model.Channel) (float64, error)
+}
+
+type ProviderResponseHandler interface {
+	// 响应处理函数
+	ResponseHandler(resp *http.Response) (OpenAIResponse any, errWithCode *types.OpenAIErrorWithStatusCode)
+}

providers/base/type.go

@@ -0,0 +1,9 @@
+package base
+
+type BalanceResponse struct {
+	Object         string  `json:"object"`
+	TotalGranted   float64 `json:"total_granted"`
+	TotalUsed      float64 `json:"total_used"`
+	TotalRemaining float64 `json:"total_remaining"`
+	TotalAvailable float64 `json:"total_available"`
+}

providers/claude/base.go

@@ -0,0 +1,50 @@
+package claude
+
+import (
+	"one-api/providers/base"
+
+	"github.com/gin-gonic/gin"
+)
+
+type ClaudeProviderFactory struct{}
+
+// 创建 ClaudeProvider
+func (f ClaudeProviderFactory) Create(c *gin.Context) base.ProviderInterface {
+	return &ClaudeProvider{
+		BaseProvider: base.BaseProvider{
+			BaseURL:         "https://api.anthropic.com",
+			ChatCompletions: "/v1/complete",
+			Context:         c,
+		},
+	}
+}
+
+type ClaudeProvider struct {
+	base.BaseProvider
+}
+
+// 获取请求头
+func (p *ClaudeProvider) GetRequestHeaders() (headers map[string]string) {
+	headers = make(map[string]string)
+	p.CommonRequestHeaders(headers)
+
+	headers["x-api-key"] = p.Channel.Key
+	anthropicVersion := p.Context.Request.Header.Get("anthropic-version")
+	if anthropicVersion == "" {
+		anthropicVersion = "2023-06-01"
+	}
+	headers["anthropic-version"] = anthropicVersion
+
+	return headers
+}
+
+func stopReasonClaude2OpenAI(reason string) string {
+	switch reason {
+	case "stop_sequence":
+		return "stop"
+	case "max_tokens":
+		return "length"
+	default:
+		return reason
+	}
+}

providers/claude/chat.go

@@ -0,0 +1,217 @@
+package claude
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"one-api/common"
+	"one-api/types"
+	"strings"
+)
+
+func (claudeResponse *ClaudeResponse) ResponseHandler(resp *http.Response) (OpenAIResponse any, errWithCode *types.OpenAIErrorWithStatusCode) {
+	if claudeResponse.Error.Type != "" {
+		return nil, &types.OpenAIErrorWithStatusCode{
+			OpenAIError: types.OpenAIError{
+				Message: claudeResponse.Error.Message,
+				Type:    claudeResponse.Error.Type,
+				Param:   "",
+				Code:    claudeResponse.Error.Type,
+			},
+			StatusCode: resp.StatusCode,
+		}
+	}
+
+	choice := types.ChatCompletionChoice{
+		Index: 0,
+		Message: types.ChatCompletionMessage{
+			Role:    "assistant",
+			Content: strings.TrimPrefix(claudeResponse.Completion, " "),
+			Name:    nil,
+		},
+		FinishReason: stopReasonClaude2OpenAI(claudeResponse.StopReason),
+	}
+	fullTextResponse := types.ChatCompletionResponse{
+		ID:      fmt.Sprintf("chatcmpl-%s", common.GetUUID()),
+		Object:  "chat.completion",
+		Created: common.GetTimestamp(),
+		Choices: []types.ChatCompletionChoice{choice},
+		Model:   claudeResponse.Model,
+	}
+
+	completionTokens := common.CountTokenText(claudeResponse.Completion, claudeResponse.Model)
+	claudeResponse.Usage.CompletionTokens = completionTokens
+	claudeResponse.Usage.TotalTokens = claudeResponse.Usage.PromptTokens + completionTokens
+
+	fullTextResponse.Usage = claudeResponse.Usage
+
+	return fullTextResponse, nil
+}
+
+func (p *ClaudeProvider) getChatRequestBody(request *types.ChatCompletionRequest) (requestBody *ClaudeRequest) {
+	claudeRequest := ClaudeRequest{
+		Model:             request.Model,
+		Prompt:            "",
+		MaxTokensToSample: request.MaxTokens,
+		StopSequences:     nil,
+		Temperature:       request.Temperature,
+		TopP:              request.TopP,
+		Stream:            request.Stream,
+	}
+	if claudeRequest.MaxTokensToSample == 0 {
+		claudeRequest.MaxTokensToSample = 1000000
+	}
+	prompt := ""
+	for _, message := range request.Messages {
+		if message.Role == "user" {
+			prompt += fmt.Sprintf("\n\nHuman: %s", message.Content)
+		} else if message.Role == "assistant" {
+			prompt += fmt.Sprintf("\n\nAssistant: %s", message.Content)
+		} else if message.Role == "system" {
+			if prompt == "" {
+				prompt = message.StringContent()
+			}
+		}
+	}
+	prompt += "\n\nAssistant:"
+	claudeRequest.Prompt = prompt
+	return &claudeRequest
+}
+
+func (p *ClaudeProvider) ChatAction(request *types.ChatCompletionRequest, isModelMapped bool, promptTokens int) (usage *types.Usage, errWithCode *types.OpenAIErrorWithStatusCode) {
+	requestBody := p.getChatRequestBody(request)
+	fullRequestURL := p.GetFullRequestURL(p.ChatCompletions, request.Model)
+	headers := p.GetRequestHeaders()
+	if request.Stream {
+		headers["Accept"] = "text/event-stream"
+	}
+
+	client := common.NewClient()
+	req, err := client.NewRequest(p.Context.Request.Method, fullRequestURL, common.WithBody(requestBody), common.WithHeader(headers))
+	if err != nil {
+		return nil, common.ErrorWrapper(err, "new_request_failed", http.StatusInternalServerError)
+	}
+
+	if request.Stream {
+		var responseText string
+		errWithCode, responseText = p.sendStreamRequest(req)
+		if errWithCode != nil {
+			return
+		}
+
+		usage = &types.Usage{
+			PromptTokens:     promptTokens,
+			CompletionTokens: common.CountTokenText(responseText, request.Model),
+		}
+		usage.TotalTokens = promptTokens + usage.CompletionTokens
+
+	} else {
+		var claudeResponse = &ClaudeResponse{
+			Usage: &types.Usage{
+				PromptTokens: promptTokens,
+			},
+		}
+		errWithCode = p.SendRequest(req, claudeResponse, false)
+		if errWithCode != nil {
+			return
+		}
+
+		usage = claudeResponse.Usage
+	}
+	return
+
+}
+
+func (p *ClaudeProvider) streamResponseClaude2OpenAI(claudeResponse *ClaudeResponse) *types.ChatCompletionStreamResponse {
+	var choice types.ChatCompletionStreamChoice
+	choice.Delta.Content = claudeResponse.Completion
+	finishReason := stopReasonClaude2OpenAI(claudeResponse.StopReason)
+	if finishReason != "null" {
+		choice.FinishReason = &finishReason
+	}
+	var response types.ChatCompletionStreamResponse
+	response.Object = "chat.completion.chunk"
+	response.Model = claudeResponse.Model
+	response.Choices = []types.ChatCompletionStreamChoice{choice}
+	return &response
+}
+
+func (p *ClaudeProvider) sendStreamRequest(req *http.Request) (*types.OpenAIErrorWithStatusCode, string) {
+	defer req.Body.Close()
+
+	// 发送请求
+	client := common.GetHttpClient(p.Channel.Proxy)
+	resp, err := client.Do(req)
+	if err != nil {
+		return common.ErrorWrapper(err, "http_request_failed", http.StatusInternalServerError), ""
+	}
+	common.PutHttpClient(client)
+
+	if common.IsFailureStatusCode(resp) {
+		return common.HandleErrorResp(resp), ""
+	}
+
+	defer resp.Body.Close()
+
+	responseText := ""
+	responseId := fmt.Sprintf("chatcmpl-%s", common.GetUUID())
+	createdTime := common.GetTimestamp()
+	scanner := bufio.NewScanner(resp.Body)
+	scanner.Split(func(data []byte, atEOF bool) (advance int, token []byte, err error) {
+		if atEOF && len(data) == 0 {
+			return 0, nil, nil
+		}
+		if i := strings.Index(string(data), "\r\n\r\n"); i >= 0 {
+			return i + 4, data[0:i], nil
+		}
+		if atEOF {
+			return len(data), data, nil
+		}
+		return 0, nil, nil
+	})
+	dataChan := make(chan string)
+	stopChan := make(chan bool)
+	go func() {
+		for scanner.Scan() {
+			data := scanner.Text()
+			if !strings.HasPrefix(data, "event: completion") {
+				continue
+			}
+			data = strings.TrimPrefix(data, "event: completion\r\ndata: ")
+			dataChan <- data
+		}
+		stopChan <- true
+	}()
+	common.SetEventStreamHeaders(p.Context)
+	p.Context.Stream(func(w io.Writer) bool {
+		select {
+		case data := <-dataChan:
+			// some implementations may add \r at the end of data
+			data = strings.TrimSuffix(data, "\r")
+			var claudeResponse ClaudeResponse
+			err := json.Unmarshal([]byte(data), &claudeResponse)
+			if err != nil {
+				common.SysError("error unmarshalling stream response: " + err.Error())
+				return true
+			}
+			responseText += claudeResponse.Completion
+			response := p.streamResponseClaude2OpenAI(&claudeResponse)
+			response.ID = responseId
+			response.Created = createdTime
+			jsonStr, err := json.Marshal(response)
+			if err != nil {
+				common.SysError("error marshalling stream response: " + err.Error())
+				return true
+			}
+			p.Context.Render(-1, common.CustomEvent{Data: "data: " + string(jsonStr)})
+			return true
+		case <-stopChan:
+			p.Context.Render(-1, common.CustomEvent{Data: "data: [DONE]"})
+			return false
+		}
+	})
+
+	return nil, responseText
+}

providers/claude/type.go

@@ -0,0 +1,32 @@
+package claude
+
+import "one-api/types"
+
+type ClaudeError struct {
+	Type    string `json:"type"`
+	Message string `json:"message"`
+}
+
+type ClaudeMetadata struct {
+	UserId string `json:"user_id"`
+}
+
+type ClaudeRequest struct {
+	Model             string   `json:"model"`
+	Prompt            string   `json:"prompt"`
+	MaxTokensToSample int      `json:"max_tokens_to_sample"`
+	StopSequences     []string `json:"stop_sequences,omitempty"`
+	Temperature       float64  `json:"temperature,omitempty"`
+	TopP              float64  `json:"top_p,omitempty"`
+	TopK              int      `json:"top_k,omitempty"`
+	//ClaudeMetadata    `json:"metadata,omitempty"`
+	Stream bool `json:"stream,omitempty"`
+}
+
+type ClaudeResponse struct {
+	Completion string       `json:"completion"`
+	StopReason string       `json:"stop_reason"`
+	Model      string       `json:"model"`
+	Error      ClaudeError  `json:"error"`
+	Usage      *types.Usage `json:"usage,omitempty"`
+}

providers/closeai/balance.go

@@ -0,0 +1,29 @@
+package closeai
+
+import (
+	"errors"
+	"one-api/common"
+	"one-api/model"
+)
+
+func (p *CloseaiProxyProvider) Balance(channel *model.Channel) (float64, error) {
+	fullRequestURL := p.GetFullRequestURL("/dashboard/billing/credit_grants", "")
+	headers := p.GetRequestHeaders()
+
+	client := common.NewClient()
+	req, err := client.NewRequest("GET", fullRequestURL, common.WithHeader(headers))
+	if err != nil {
+		return 0, err
+	}
+
+	// 发送请求
+	var response OpenAICreditGrants
+	_, errWithCode := common.SendRequest(req, &response, false, p.Channel.Proxy)
+	if errWithCode != nil {
+		return 0, errors.New(errWithCode.OpenAIError.Message)
+	}
+
+	channel.UpdateBalance(response.TotalAvailable)
+
+	return response.TotalAvailable, nil
+}

providers/closeai/base.go

@@ -0,0 +1,21 @@
+package closeai
+
+import (
+	"one-api/providers/base"
+	"one-api/providers/openai"
+
+	"github.com/gin-gonic/gin"
+)
+
+type CloseaiProviderFactory struct{}
+
+// 创建 CloseaiProvider
+func (f CloseaiProviderFactory) Create(c *gin.Context) base.ProviderInterface {
+	return &CloseaiProxyProvider{
+		OpenAIProvider: openai.CreateOpenAIProvider(c, "https://api.closeai-proxy.xyz"),
+	}
+}
+
+type CloseaiProxyProvider struct {
+	*openai.OpenAIProvider
+}

providers/closeai/type.go

@@ -0,0 +1,8 @@
+package closeai
+
+type OpenAICreditGrants struct {
+	Object         string  `json:"object"`
+	TotalGranted   float64 `json:"total_granted"`
+	TotalUsed      float64 `json:"total_used"`
+	TotalAvailable float64 `json:"total_available"`
+}

providers/gemini/base.go

@@ -0,0 +1,46 @@
+package gemini
+
+import (
+	"fmt"
+	"one-api/providers/base"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+)
+
+type GeminiProviderFactory struct{}
+
+// 创建 ClaudeProvider
+func (f GeminiProviderFactory) Create(c *gin.Context) base.ProviderInterface {
+	return &GeminiProvider{
+		BaseProvider: base.BaseProvider{
+			BaseURL:         "https://generativelanguage.googleapis.com",
+			ChatCompletions: "/",
+			Context:         c,
+		},
+	}
+}
+
+type GeminiProvider struct {
+	base.BaseProvider
+}
+
+func (p *GeminiProvider) GetFullRequestURL(requestURL string, modelName string) string {
+	baseURL := strings.TrimSuffix(p.GetBaseURL(), "/")
+	version := "v1"
+	if p.Channel.Other != "" {
+		version = p.Channel.Other
+	}
+
+	return fmt.Sprintf("%s/%s/models/%s:%s", baseURL, version, modelName, requestURL)
+
+}
+
+// 获取请求头
+func (p *GeminiProvider) GetRequestHeaders() (headers map[string]string) {
+	headers = make(map[string]string)
+	p.CommonRequestHeaders(headers)
+	headers["x-goog-api-key"] = p.Channel.Key
+
+	return headers
+}

providers/gemini/chat.go

@@ -0,0 +1,297 @@
+package gemini
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"one-api/common"
+	"one-api/common/image"
+	"one-api/providers/base"
+	"one-api/types"
+	"strings"
+)
+
+const (
+	GeminiVisionMaxImageNum = 16
+)
+
+func (response *GeminiChatResponse) ResponseHandler(resp *http.Response) (OpenAIResponse any, errWithCode *types.OpenAIErrorWithStatusCode) {
+	if len(response.Candidates) == 0 {
+		return nil, &types.OpenAIErrorWithStatusCode{
+			OpenAIError: types.OpenAIError{
+				Message: "No candidates returned",
+				Type:    "server_error",
+				Param:   "",
+				Code:    500,
+			},
+			StatusCode: resp.StatusCode,
+		}
+	}
+
+	fullTextResponse := &types.ChatCompletionResponse{
+		ID:      fmt.Sprintf("chatcmpl-%s", common.GetUUID()),
+		Object:  "chat.completion",
+		Created: common.GetTimestamp(),
+		Model:   response.Model,
+		Choices: make([]types.ChatCompletionChoice, 0, len(response.Candidates)),
+	}
+	for i, candidate := range response.Candidates {
+		choice := types.ChatCompletionChoice{
+			Index: i,
+			Message: types.ChatCompletionMessage{
+				Role:    "assistant",
+				Content: "",
+			},
+			FinishReason: base.StopFinishReason,
+		}
+		if len(candidate.Content.Parts) > 0 {
+			choice.Message.Content = candidate.Content.Parts[0].Text
+		}
+		fullTextResponse.Choices = append(fullTextResponse.Choices, choice)
+	}
+
+	completionTokens := common.CountTokenText(response.GetResponseText(), response.Model)
+	response.Usage.CompletionTokens = completionTokens
+	response.Usage.TotalTokens = response.Usage.PromptTokens + completionTokens
+
+	return fullTextResponse, nil
+}
+
+// Setting safety to the lowest possible values since Gemini is already powerless enough
+func (p *GeminiProvider) getChatRequestBody(request *types.ChatCompletionRequest) (requestBody *GeminiChatRequest) {
+	geminiRequest := GeminiChatRequest{
+		Contents: make([]GeminiChatContent, 0, len(request.Messages)),
+		//SafetySettings: []GeminiChatSafetySettings{
+		//	{
+		//		Category:  "HARM_CATEGORY_HARASSMENT",
+		//		Threshold: "BLOCK_ONLY_HIGH",
+		//	},
+		//	{
+		//		Category:  "HARM_CATEGORY_HATE_SPEECH",
+		//		Threshold: "BLOCK_ONLY_HIGH",
+		//	},
+		//	{
+		//		Category:  "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+		//		Threshold: "BLOCK_ONLY_HIGH",
+		//	},
+		//	{
+		//		Category:  "HARM_CATEGORY_DANGEROUS_CONTENT",
+		//		Threshold: "BLOCK_ONLY_HIGH",
+		//	},
+		//},
+		GenerationConfig: GeminiChatGenerationConfig{
+			Temperature:     request.Temperature,
+			TopP:            request.TopP,
+			MaxOutputTokens: request.MaxTokens,
+		},
+	}
+	if request.Functions != nil {
+		geminiRequest.Tools = []GeminiChatTools{
+			{
+				FunctionDeclarations: request.Functions,
+			},
+		}
+	}
+	shouldAddDummyModelMessage := false
+	for _, message := range request.Messages {
+		content := GeminiChatContent{
+			Role: message.Role,
+			Parts: []GeminiPart{
+				{
+					Text: message.StringContent(),
+				},
+			},
+		}
+
+		openaiContent := message.ParseContent()
+		var parts []GeminiPart
+		imageNum := 0
+		for _, part := range openaiContent {
+			if part.Type == types.ContentTypeText {
+				parts = append(parts, GeminiPart{
+					Text: part.Text,
+				})
+			} else if part.Type == types.ContentTypeImageURL {
+				imageNum += 1
+				if imageNum > GeminiVisionMaxImageNum {
+					continue
+				}
+				mimeType, data, _ := image.GetImageFromUrl(part.ImageURL.URL)
+				parts = append(parts, GeminiPart{
+					InlineData: &GeminiInlineData{
+						MimeType: mimeType,
+						Data:     data,
+					},
+				})
+			}
+		}
+		content.Parts = parts
+
+		// there's no assistant role in gemini and API shall vomit if Role is not user or model
+		if content.Role == "assistant" {
+			content.Role = "model"
+		}
+		// Converting system prompt to prompt from user for the same reason
+		if content.Role == "system" {
+			content.Role = "user"
+			shouldAddDummyModelMessage = true
+		}
+		geminiRequest.Contents = append(geminiRequest.Contents, content)
+
+		// If a system message is the last message, we need to add a dummy model message to make gemini happy
+		if shouldAddDummyModelMessage {
+			geminiRequest.Contents = append(geminiRequest.Contents, GeminiChatContent{
+				Role: "model",
+				Parts: []GeminiPart{
+					{
+						Text: "Okay",
+					},
+				},
+			})
+			shouldAddDummyModelMessage = false
+		}
+	}
+
+	return &geminiRequest
+}
+
+func (p *GeminiProvider) ChatAction(request *types.ChatCompletionRequest, isModelMapped bool, promptTokens int) (usage *types.Usage, errWithCode *types.OpenAIErrorWithStatusCode) {
+	requestBody := p.getChatRequestBody(request)
+	fullRequestURL := p.GetFullRequestURL("generateContent", request.Model)
+	headers := p.GetRequestHeaders()
+	if request.Stream {
+		headers["Accept"] = "text/event-stream"
+	}
+
+	client := common.NewClient()
+	req, err := client.NewRequest(p.Context.Request.Method, fullRequestURL, common.WithBody(requestBody), common.WithHeader(headers))
+	if err != nil {
+		return nil, common.ErrorWrapper(err, "new_request_failed", http.StatusInternalServerError)
+	}
+
+	if request.Stream {
+		var responseText string
+		errWithCode, responseText = p.sendStreamRequest(req, request.Model)
+		if errWithCode != nil {
+			return
+		}
+
+		usage = &types.Usage{
+			PromptTokens:     promptTokens,
+			CompletionTokens: common.CountTokenText(responseText, request.Model),
+		}
+		usage.TotalTokens = promptTokens + usage.CompletionTokens
+
+	} else {
+		var geminiResponse = &GeminiChatResponse{
+			Model: request.Model,
+			Usage: &types.Usage{
+				PromptTokens: promptTokens,
+			},
+		}
+		errWithCode = p.SendRequest(req, geminiResponse, false)
+		if errWithCode != nil {
+			return
+		}
+
+		usage = geminiResponse.Usage
+	}
+	return
+
+}
+
+// func (p *GeminiProvider) streamResponseClaude2OpenAI(geminiResponse *GeminiChatResponse) *types.ChatCompletionStreamResponse {
+// 	var choice types.ChatCompletionStreamChoice
+// 	choice.Delta.Content = geminiResponse.GetResponseText()
+// 	choice.FinishReason = &base.StopFinishReason
+// 	var response types.ChatCompletionStreamResponse
+// 	response.Object = "chat.completion.chunk"
+// 	response.Model = "gemini"
+// 	response.Choices = []types.ChatCompletionStreamChoice{choice}
+// 	return &response
+// }
+
+func (p *GeminiProvider) sendStreamRequest(req *http.Request, model string) (*types.OpenAIErrorWithStatusCode, string) {
+	defer req.Body.Close()
+
+	// 发送请求
+	client := common.GetHttpClient(p.Channel.Proxy)
+	resp, err := client.Do(req)
+	if err != nil {
+		return common.ErrorWrapper(err, "http_request_failed", http.StatusInternalServerError), ""
+	}
+	common.PutHttpClient(client)
+
+	if common.IsFailureStatusCode(resp) {
+		return common.HandleErrorResp(resp), ""
+	}
+
+	defer resp.Body.Close()
+
+	responseText := ""
+	dataChan := make(chan string)
+	stopChan := make(chan bool)
+	scanner := bufio.NewScanner(resp.Body)
+	scanner.Split(func(data []byte, atEOF bool) (advance int, token []byte, err error) {
+		if atEOF && len(data) == 0 {
+			return 0, nil, nil
+		}
+		if i := strings.Index(string(data), "\n"); i >= 0 {
+			return i + 1, data[0:i], nil
+		}
+		if atEOF {
+			return len(data), data, nil
+		}
+		return 0, nil, nil
+	})
+	go func() {
+		for scanner.Scan() {
+			data := scanner.Text()
+			data = strings.TrimSpace(data)
+			if !strings.HasPrefix(data, "\"text\": \"") {
+				continue
+			}
+			data = strings.TrimPrefix(data, "\"text\": \"")
+			data = strings.TrimSuffix(data, "\"")
+			dataChan <- data
+		}
+		stopChan <- true
+	}()
+	common.SetEventStreamHeaders(p.Context)
+	p.Context.Stream(func(w io.Writer) bool {
+		select {
+		case data := <-dataChan:
+			// this is used to prevent annoying \ related format bug
+			data = fmt.Sprintf("{\"content\": \"%s\"}", data)
+			type dummyStruct struct {
+				Content string `json:"content"`
+			}
+			var dummy dummyStruct
+			json.Unmarshal([]byte(data), &dummy)
+			responseText += dummy.Content
+			var choice types.ChatCompletionStreamChoice
+			choice.Delta.Content = dummy.Content
+			response := types.ChatCompletionStreamResponse{
+				ID:      fmt.Sprintf("chatcmpl-%s", common.GetUUID()),
+				Object:  "chat.completion.chunk",
+				Created: common.GetTimestamp(),
+				Model:   model,
+				Choices: []types.ChatCompletionStreamChoice{choice},
+			}
+			jsonResponse, err := json.Marshal(response)
+			if err != nil {
+				common.SysError("error marshalling stream response: " + err.Error())
+				return true
+			}
+			p.Context.Render(-1, common.CustomEvent{Data: "data: " + string(jsonResponse)})
+			return true
+		case <-stopChan:
+			p.Context.Render(-1, common.CustomEvent{Data: "data: [DONE]"})
+			return false
+		}
+	})
+
+	return nil, responseText
+}

providers/gemini/type.go

@@ -0,0 +1,76 @@
+package gemini
+
+import "one-api/types"
+
+type GeminiChatRequest struct {
+	Contents         []GeminiChatContent        `json:"contents"`
+	SafetySettings   []GeminiChatSafetySettings `json:"safety_settings,omitempty"`
+	GenerationConfig GeminiChatGenerationConfig `json:"generation_config,omitempty"`
+	Tools            []GeminiChatTools          `json:"tools,omitempty"`
+}
+
+type GeminiInlineData struct {
+	MimeType string `json:"mimeType"`
+	Data     string `json:"data"`
+}
+
+type GeminiPart struct {
+	Text       string            `json:"text,omitempty"`
+	InlineData *GeminiInlineData `json:"inlineData,omitempty"`
+}
+
+type GeminiChatContent struct {
+	Role  string       `json:"role,omitempty"`
+	Parts []GeminiPart `json:"parts"`
+}
+
+type GeminiChatSafetySettings struct {
+	Category  string `json:"category"`
+	Threshold string `json:"threshold"`
+}
+
+type GeminiChatTools struct {
+	FunctionDeclarations any `json:"functionDeclarations,omitempty"`
+}
+
+type GeminiChatGenerationConfig struct {
+	Temperature     float64  `json:"temperature,omitempty"`
+	TopP            float64  `json:"topP,omitempty"`
+	TopK            float64  `json:"topK,omitempty"`
+	MaxOutputTokens int      `json:"maxOutputTokens,omitempty"`
+	CandidateCount  int      `json:"candidateCount,omitempty"`
+	StopSequences   []string `json:"stopSequences,omitempty"`
+}
+
+type GeminiChatResponse struct {
+	Candidates     []GeminiChatCandidate    `json:"candidates"`
+	PromptFeedback GeminiChatPromptFeedback `json:"promptFeedback"`
+	Usage          *types.Usage             `json:"usage,omitempty"`
+	Model          string                   `json:"model,omitempty"`
+}
+
+type GeminiChatCandidate struct {
+	Content       GeminiChatContent        `json:"content"`
+	FinishReason  string                   `json:"finishReason"`
+	Index         int64                    `json:"index"`
+	SafetyRatings []GeminiChatSafetyRating `json:"safetyRatings"`
+}
+
+type GeminiChatSafetyRating struct {
+	Category    string `json:"category"`
+	Probability string `json:"probability"`
+}
+
+type GeminiChatPromptFeedback struct {
+	SafetyRatings []GeminiChatSafetyRating `json:"safetyRatings"`
+}
+
+func (g *GeminiChatResponse) GetResponseText() string {
+	if g == nil {
+		return ""
+	}
+	if len(g.Candidates) > 0 && len(g.Candidates[0].Content.Parts) > 0 {
+		return g.Candidates[0].Content.Parts[0].Text
+	}
+	return ""
+}