Delete new-api

new-api/.dockerignore

@@ -1,8 +0,0 @@
-.github
-.git
-*.md
-.vscode
-.gitignore
-Makefile
-docs
-.eslintcache

new-api/.env.example

@@ -1,73 +0,0 @@
-# 端口号
-# PORT=3000
-# 前端基础URL
-# FRONTEND_BASE_URL=https://your-frontend-url.com
-
-
-# 调试相关配置
-# 启用pprof
-# ENABLE_PPROF=true
-# 启用调试模式
-# DEBUG=true
-
-# 数据库相关配置
-# 数据库连接字符串
-# SQL_DSN=user:password@tcp(127.0.0.1:3306)/dbname?parseTime=true
-# 日志数据库连接字符串
-# LOG_SQL_DSN=user:password@tcp(127.0.0.1:3306)/logdb?parseTime=true
-# SQLite数据库路径
-# SQLITE_PATH=/path/to/sqlite.db
-# 数据库最大空闲连接数
-# SQL_MAX_IDLE_CONNS=100
-# 数据库最大打开连接数
-# SQL_MAX_OPEN_CONNS=1000
-# 数据库连接最大生命周期（秒）
-# SQL_MAX_LIFETIME=60
-
-
-# 缓存相关配置
-# Redis连接字符串
-# REDIS_CONN_STRING=redis://user:password@localhost:6379/0
-# 同步频率（单位：秒）
-# SYNC_FREQUENCY=60
-# 内存缓存启用
-# MEMORY_CACHE_ENABLED=true
-# 渠道更新频率（单位：秒）
-# CHANNEL_UPDATE_FREQUENCY=30
-# 批量更新启用
-# BATCH_UPDATE_ENABLED=true
-# 批量更新间隔（单位：秒）
-# BATCH_UPDATE_INTERVAL=5
-
-# 任务和功能配置
-# 更新任务启用
-# UPDATE_TASK=true
-
-# 对话超时设置
-# 所有请求超时时间，单位秒，默认为0，表示不限制
-# RELAY_TIMEOUT=0
-# 流模式无响应超时时间，单位秒，如果出现空补全可以尝试改为更大值
-# STREAMING_TIMEOUT=300
-
-# Gemini 识别图片 最大图片数量
-# GEMINI_VISION_MAX_IMAGE_NUM=16
-
-# 会话密钥
-# SESSION_SECRET=random_string
-
-# 其他配置
-# 生成默认token
-# GENERATE_DEFAULT_TOKEN=false
-# Cohere 安全设置
-# COHERE_SAFETY_SETTING=NONE
-# 是否统计图片token
-# GET_MEDIA_TOKEN=true
-# 是否在非流（stream=false）情况下统计图片token
-# GET_MEDIA_TOKEN_NOT_STREAM=true
-# 设置 Dify 渠道是否输出工作流和节点信息到客户端
-# DIFY_DEBUG=true
-
-
-# 节点类型
-# 如果是主节点则为master
-# NODE_TYPE=master

new-api/.gitignore

@@ -1,14 +0,0 @@
-.idea
-.vscode
-upload
-*.exe
-*.db
-build
-*.db-journal
-logs
-web/dist
-.env
-one-api
-.DS_Store
-tiktoken_cache
-.eslintcache

new-api/Dockerfile

@@ -1,35 +0,0 @@
-FROM oven/bun:latest AS builder
-
-WORKDIR /build
-COPY web/package.json .
-COPY web/bun.lock .
-RUN bun install
-COPY ./web .
-COPY ./VERSION .
-RUN DISABLE_ESLINT_PLUGIN='true' VITE_REACT_APP_VERSION=$(cat VERSION) bun run build
-
-FROM golang:alpine AS builder2
-
-ENV GO111MODULE=on \
-    CGO_ENABLED=0 \
-    GOOS=linux
-
-WORKDIR /build
-
-ADD go.mod go.sum ./
-RUN go mod download
-
-COPY . .
-COPY --from=builder /build/dist ./web/dist
-RUN go build -ldflags "-s -w -X 'one-api/common.Version=$(cat VERSION)'" -o one-api
-
-FROM alpine
-
-RUN apk upgrade --no-cache \
-    && apk add --no-cache ca-certificates tzdata ffmpeg \
-    && update-ca-certificates
-
-COPY --from=builder2 /build/one-api /
-EXPOSE 3000
-WORKDIR /data
-ENTRYPOINT ["/one-api"]

new-api/LICENSE

@@ -1,103 +0,0 @@
-# **New API 许可协议 (Licensing)**
-
-本项目采用**基于使用场景的双重许可 (Usage-Based Dual Licensing)** 模式。
-
-**核心原则：**
-
-- **默认许可:** 本项目默认在 **GNU Affero 通用公共许可证 v3.0 (AGPLv3)** 下提供。任何用户在遵守 AGPLv3 条款和下述附加限制的前提下，均可免费使用。
-- **商业许可:** 在特定商业场景下，或当您希望获得 AGPLv3 之外的权利时，**必须**获取**商业许可证 (Commercial License)**。
-
----
-
-## **1. 开源许可证 (Open Source License): AGPLv3 - 适用于基础使用**
-
-- 在遵守 **AGPLv3** 条款的前提下，您可以自由地使用、修改和分发 New API。AGPLv3 的完整文本可以访问 [https://www.gnu.org/licenses/agpl-3.0.html](https://www.gnu.org/licenses/agpl-3.0.html) 获取。
-- **核心义务:** AGPLv3 的一个关键要求是，如果您修改了 New API 并通过网络提供服务 (SaaS)，或者分发了修改后的版本，您必须以 AGPLv3 许可证向所有用户提供相应的**完整源代码**。
-- **附加限制 (重要):** 在仅使用 AGPLv3 开源许可证的情况下，您**必须**完整保留项目代码中原有的品牌标识、LOGO 及版权声明信息。**禁止以任何形式修改、移除或遮盖**这些信息。如需移除，必须获取商业许可证。
-- 使用前请务必仔细阅读并理解 AGPLv3 的所有条款及上述附加限制。
-
-## **2. 商业许可证 (Commercial License) - 适用于高级场景及闭源需求**
-
-在以下任一情况下，您**必须**联系我们获取并签署一份商业许可证，才能合法使用 New API：
-
-- **场景一：移除品牌和版权信息**  
-  您希望在您的产品或服务中移除 New API 的 LOGO、UI界面中的版权声明或其他品牌标识。
-
-- **场景二：规避 AGPLv3 开源义务**  
-  您基于 New API 进行了修改，并希望：  
-    - 通过网络提供服务（SaaS），但**不希望**向您的服务用户公开您修改后的源代码。  
-    - 分发一个集成了 New API 的软件产品，但**不希望**以 AGPLv3 许可证发布您的产品或公开源代码。
-
-- **场景三：企业政策与集成需求**  
-    - 您所在公司的政策、客户合同或项目要求不允许使用 AGPLv3 许可的软件。  
-    - 您需要进行 OEM 集成，将 New API 作为您闭源商业产品的一部分进行再分发。
-
-- **场景四：需要商业支持与保障**  
-    您需要 AGPLv3 未提供的商业保障，如官方技术支持等。
-
-**获取商业许可：**  
-请通过电子邮件 **support@quantumnous.com** 联系 New API 团队洽谈商业授权事宜。
-
-## **3. 贡献 (Contributions)**
-
-- 我们欢迎社区对 New API 的贡献。所有向本项目提交的贡献（例如通过 Pull Request）都将被视为在 **AGPLv3** 许可证下提供。
-- 通过向本项目提交贡献，即表示您同意您的代码以 AGPLv3 许可证授权给本项目及所有后续使用者（无论这些使用者最终遵循 AGPLv3 还是商业许可）。
-- 您也理解并同意，您的贡献可能会被包含在根据商业许可证分发的 New API 版本中。
-
-## **4. 其他条款 (Other Terms)**
-
-- 关于商业许可证的具体条款、条件和价格，以双方签署的正式商业许可协议为准。
-- 项目维护者保留根据需要更新本许可政策的权利。相关更新将通过项目官方渠道（如代码仓库、官方网站）进行通知。
-
----
-
-# **New API Licensing**
-
-This project uses a **Usage-Based Dual Licensing** model.
-
-**Core Principles:**
-
-- **Default License:** This project is available by default under the **GNU Affero General Public License v3.0 (AGPLv3)**. Any user may use it free of charge, provided they comply with both the AGPLv3 terms and the additional restrictions listed below.
-- **Commercial License:** For specific commercial scenarios, or if you require rights beyond those granted by AGPLv3, you **must** obtain a **Commercial License**.
-
----
-
-## **1. Open Source License: AGPLv3 – For Basic Usage**
-
-- Under the terms of the **AGPLv3**, you are free to use, modify, and distribute New API. The complete AGPLv3 license text can be viewed at [https://www.gnu.org/licenses/agpl-3.0.html](https://www.gnu.org/licenses/agpl-3.0.html).
-- **Core Obligation:** A key AGPLv3 requirement is that if you modify New API and provide it as a network service (SaaS), or distribute a modified version, you must make the **complete corresponding source code** available to all users under the AGPLv3 license.
-- **Additional Restriction (Important):** When using only the AGPLv3 open-source license, you **must** retain all original branding, logos, and copyright statements within the project’s code. **You are strictly prohibited from modifying, removing, or concealing** any such information. If you wish to remove this, you must obtain a Commercial License.
-- Please read and ensure that you fully understand all AGPLv3 terms and the above additional restriction before use.
-
-## **2. Commercial License – For Advanced Scenarios & Closed Source Needs**
-
-You **must** contact us to obtain and sign a Commercial License in any of the following scenarios in order to legally use New API:
-
-- **Scenario 1: Removal of Branding and Copyright**  
-  You wish to remove the New API logo, copyright statement, or other branding elements from your product or service.
-
-- **Scenario 2: Avoidance of AGPLv3 Open Source Obligations**  
-  You have modified New API and wish to:
-    - Offer it as a network service (SaaS) **without** disclosing your modifications' source code to your users.
-    - Distribute a software product integrated with New API **without** releasing your product under AGPLv3 or open-sourcing the code.
-
-- **Scenario 3: Enterprise Policy & Integration Needs**  
-    - Your organization’s policies, client contracts, or project requirements prohibit the use of AGPLv3-licensed software.
-    - You require OEM integration and need to redistribute New API as part of your closed-source commercial product.
-
-- **Scenario 4: Commercial Support and Assurances**  
-    You require commercial assurances not provided by AGPLv3, such as official technical support.
-
-**Obtaining a Commercial License:**  
-Please contact the New API team via email at **support@quantumnous.com** to discuss commercial licensing.
-
-## **3. Contributions**
-
-- We welcome community contributions to New API. All contributions (e.g., via Pull Request) are deemed to be provided under the **AGPLv3** license.
-- By submitting a contribution, you agree that your code is licensed to this project and all downstream users under the AGPLv3 license (regardless of whether those users ultimately operate under AGPLv3 or a Commercial License).
-- You also acknowledge and agree that your contribution may be included in New API releases distributed under a Commercial License.
-
-## **4. Other Terms**
-
-- The specific terms, conditions, and pricing of the Commercial License are governed by the formal commercial license agreement executed by both parties.
-- Project maintainers reserve the right to update this licensing policy as needed. Updates will be communicated via official project channels (e.g., repository, official website).

new-api/README.en.md

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

new-api/README.fr.md

@@ -1,216 +0,0 @@
-<p align="right">
-   <a href="./README.md">中文</a> | <a href="./README.en.md">English</a> | <strong>Français</strong>
-</p>
-<div align="center">
-
-![new-api](/web/public/logo.png)
-
-# New API
-
-🍥 Passerelle de modèles étendus de nouvelle génération et système de gestion d'actifs d'IA
-
-<a href="https://trendshift.io/repositories/8227" target="_blank"><img src="https://trendshift.io/api/badge/repositories/8227" alt="Calcium-Ion%2Fnew-api | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
-
-<p align="center">
-  <a href="https://raw.githubusercontent.com/Calcium-Ion/new-api/main/LICENSE">
-    <img src="https://img.shields.io/github/license/Calcium-Ion/new-api?color=brightgreen" alt="licence">
-  </a>
-  <a href="https://github.com/Calcium-Ion/new-api/releases/latest">
-    <img src="https://img.shields.io/github/v/release/Calcium-Ion/new-api?color=brightgreen&include_prereleases" alt="version">
-  </a>
-  <a href="https://github.com/users/Calcium-Ion/packages/container/package/new-api">
-    <img src="https://img.shields.io/badge/docker-ghcr.io-blue" alt="docker">
-  </a>
-  <a href="https://hub.docker.com/r/CalciumIon/new-api">
-    <img src="https://img.shields.io/badge/docker-dockerHub-blue" alt="docker">
-  </a>
-  <a href="https://goreportcard.com/report/github.com/Calcium-Ion/new-api">
-    <img src="https://goreportcard.com/badge/github.com/Calcium-Ion/new-api" alt="GoReportCard">
-  </a>
-</p>
-</div>
-
-## 📝 Description du projet
-
-> [!NOTE]
-> Il s'agit d'un projet open-source développé sur la base de [One API](https://github.com/songquanpeng/one-api)
-
-> [!IMPORTANT]
-> - Ce projet est uniquement destiné à des fins d'apprentissage personnel, sans garantie de stabilité ni de support technique.
-> - Les utilisateurs doivent se conformer aux [Conditions d'utilisation](https://openai.com/policies/terms-of-use) d'OpenAI et aux **lois et réglementations applicables**, et ne doivent pas l'utiliser à des fins illégales.
-> - Conformément aux [《Mesures provisoires pour la gestion des services d'intelligence artificielle générative》](http://www.cac.gov.cn/2023-07/13/c_1690898327029107.htm), veuillez ne fournir aucun service d'IA générative non enregistré au public en Chine.
-
-<h2>🤝 Partenaires de confiance</h2>
-<p id="premium-sponsors">&nbsp;</p>
-<p align="center"><strong>Sans ordre particulier</strong></p>
-<p align="center">
-  <a href="https://www.cherry-ai.com/" target=_blank><img
-    src="./docs/images/cherry-studio.png" alt="Cherry Studio" height="120"
-  /></a>
-  <a href="https://bda.pku.edu.cn/" target=_blank><img
-    src="./docs/images/pku.png" alt="Université de Pékin" height="120"
-  /></a>
-  <a href="https://www.compshare.cn/?ytag=GPU_yy_gh_newapi" target=_blank><img
-    src="./docs/images/ucloud.png" alt="UCloud" height="120"
-  /></a>
-  <a href="https://www.aliyun.com/" target=_blank><img
-    src="./docs/images/aliyun.png" alt="Alibaba Cloud" height="120"
-  /></a>
-  <a href="https://io.net/" target=_blank><img
-    src="./docs/images/io-net.png" alt="IO.NET" height="120"
-  /></a>
-</p>
-<p>&nbsp;</p>
-
-## 📚 Documentation
-
-Pour une documentation détaillée, veuillez consulter notre Wiki officiel : [https://docs.newapi.pro/](https://docs.newapi.pro/)
-
-Vous pouvez également accéder au DeepWiki généré par l'IA :
-[![Demander à DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/QuantumNous/new-api)
-
-## ✨ Fonctionnalités clés
-
-New API offre un large éventail de fonctionnalités, veuillez vous référer à [Présentation des fonctionnalités](https://docs.newapi.pro/wiki/features-introduction) pour plus de détails :
-
-1. 🎨 Nouvelle interface utilisateur
-2. 🌍 Prise en charge multilingue
-3. 💰 Fonctionnalité de recharge en ligne (YiPay)
-4. 🔍 Prise en charge de la recherche de quotas d'utilisation avec des clés (fonctionne avec [neko-api-key-tool](https://github.com/Calcium-Ion/neko-api-key-tool))
-5. 🔄 Compatible avec la base de données originale de One API
-6. 💵 Prise en charge de la tarification des modèles de paiement à l'utilisation
-7. ⚖️ Prise en charge de la sélection aléatoire pondérée des canaux
-8. 📈 Tableau de bord des données (console)
-9. 🔒 Regroupement de jetons et restrictions de modèles
-10. 🤖 Prise en charge de plus de méthodes de connexion par autorisation (LinuxDO, Telegram, OIDC)
-11. 🔄 Prise en charge des modèles Rerank (Cohere et Jina), [Documentation de l'API](https://docs.newapi.pro/api/jinaai-rerank)
-12. ⚡ Prise en charge de l'API OpenAI Realtime (y compris les canaux Azure), [Documentation de l'API](https://docs.newapi.pro/api/openai-realtime)
-13. ⚡ Prise en charge du format Claude Messages, [Documentation de l'API](https://docs.newapi.pro/api/anthropic-chat)
-14. Prise en charge de l'accès à l'interface de discussion via la route /chat2link
-15. 🧠 Prise en charge de la définition de l'effort de raisonnement via les suffixes de nom de modèle :
-    1. Modèles de la série o d'OpenAI
-        - Ajouter le suffixe `-high` pour un effort de raisonnement élevé (par exemple : `o3-mini-high`)
-        - Ajouter le suffixe `-medium` pour un effort de raisonnement moyen (par exemple : `o3-mini-medium`)
-        - Ajouter le suffixe `-low` pour un effort de raisonnement faible (par exemple : `o3-mini-low`)
-    2. Modèles de pensée de Claude
-        - Ajouter le suffixe `-thinking` pour activer le mode de pensée (par exemple : `claude-3-7-sonnet-20250219-thinking`)
-16. 🔄 Fonctionnalité de la pensée au contenu
-17. 🔄 Limitation du débit du modèle pour les utilisateurs
-18. 💰 Prise en charge de la facturation du cache, qui permet de facturer à un ratio défini lorsque le cache est atteint :
-    1. Définir l'option `Ratio de cache d'invite` dans `Paramètres système->Paramètres de fonctionnement`
-    2. Définir le `Ratio de cache d'invite` dans le canal, plage de 0 à 1, par exemple, le définir sur 0,5 signifie facturer à 50 % lorsque le cache est atteint
-    3. Canaux pris en charge :
-        - [x] OpenAI
-        - [x] Azure
-        - [x] DeepSeek
-        - [x] Claude
-
-## Prise en charge des modèles
-
-Cette version prend en charge plusieurs modèles, veuillez vous référer à [Documentation de l'API-Interface de relais](https://docs.newapi.pro/api) pour plus de détails :
-
-1. Modèles tiers **gpts** (gpt-4-gizmo-*)
-2. Canal tiers [Midjourney-Proxy(Plus)](https://github.com/novicezk/midjourney-proxy), [Documentation de l'API](https://docs.newapi.pro/api/midjourney-proxy-image)
-3. Canal tiers [Suno API](https://github.com/Suno-API/Suno-API), [Documentation de l'API](https://docs.newapi.pro/api/suno-music)
-4. Canaux personnalisés, prenant en charge la saisie complète de l'adresse d'appel
-5. Modèles Rerank ([Cohere](https://cohere.ai/) et [Jina](https://jina.ai/)), [Documentation de l'API](https://docs.newapi.pro/api/jinaai-rerank)
-6. Format de messages Claude, [Documentation de l'API](https://docs.newapi.pro/api/anthropic-chat)
-7. Dify, ne prend actuellement en charge que chatflow
-
-## Configuration des variables d'environnement
-
-Pour des instructions de configuration détaillées, veuillez vous référer à [Guide d'installation-Configuration des variables d'environnement](https://docs.newapi.pro/installation/environment-variables) :
-
-- `GENERATE_DEFAULT_TOKEN` : S'il faut générer des jetons initiaux pour les utilisateurs nouvellement enregistrés, la valeur par défaut est `false`
-- `STREAMING_TIMEOUT` : Délai d'expiration de la réponse en streaming, la valeur par défaut est de 300 secondes
-- `DIFY_DEBUG` : S'il faut afficher les informations sur le flux de travail et les nœuds pour les canaux Dify, la valeur par défaut est `true`
-- `FORCE_STREAM_OPTION` : S'il faut remplacer le paramètre client stream_options, la valeur par défaut est `true`
-- `GET_MEDIA_TOKEN` : S'il faut compter les jetons d'image, la valeur par défaut est `true`
-- `GET_MEDIA_TOKEN_NOT_STREAM` : S'il faut compter les jetons d'image dans les cas sans streaming, la valeur par défaut est `true`
-- `UPDATE_TASK` : S'il faut mettre à jour les tâches asynchrones (Midjourney, Suno), la valeur par défaut est `true`
-- `COHERE_SAFETY_SETTING` : Paramètres de sécurité du modèle Cohere, les options sont `NONE`, `CONTEXTUAL`, `STRICT`, la valeur par défaut est `NONE`
-- `GEMINI_VISION_MAX_IMAGE_NUM` : Nombre maximum d'images pour les modèles Gemini, la valeur par défaut est `16`
-- `MAX_FILE_DOWNLOAD_MB` : Taille maximale de téléchargement de fichier en Mo, la valeur par défaut est `20`
-- `CRYPTO_SECRET` : Clé de chiffrement utilisée pour chiffrer le contenu de la base de données
-- `AZURE_DEFAULT_API_VERSION` : Version de l'API par défaut du canal Azure, la valeur par défaut est `2025-04-01-preview`
-- `NOTIFICATION_LIMIT_DURATION_MINUTE` : Durée de la limite de notification, la valeur par défaut est de `10` minutes
-- `NOTIFY_LIMIT_COUNT` : Nombre maximal de notifications utilisateur dans la durée spécifiée, la valeur par défaut est `2`
-- `ERROR_LOG_ENABLED=true` : S'il faut enregistrer et afficher les journaux d'erreurs, la valeur par défaut est `false`
-
-## Déploiement
-
-Pour des guides de déploiement détaillés, veuillez vous référer à [Guide d'installation-Méthodes de déploiement](https://docs.newapi.pro/installation) :
-
-> [!TIP]
-> Dernière image Docker : `calciumion/new-api:latest`
-
-### Considérations sur le déploiement multi-machines
-- La variable d'environnement `SESSION_SECRET` doit être définie, sinon l'état de connexion sera incohérent sur plusieurs machines
-- Si vous partagez Redis, `CRYPTO_SECRET` doit être défini, sinon le contenu de Redis ne pourra pas être consulté sur plusieurs machines
-
-### Exigences de déploiement
-- Base de données locale (par défaut) : SQLite (le déploiement Docker doit monter le répertoire `/data`)
-- Base de données distante : MySQL version >= 5.7.8, PgSQL version >= 9.6
-
-### Méthodes de déploiement
-
-#### Utilisation de la fonctionnalité Docker du panneau BaoTa
-Installez le panneau BaoTa (version **9.2.0** ou supérieure), recherchez **New-API** dans le magasin d'applications et installez-le.
-[Tutoriel avec des images](./docs/BT.md)
-
-#### Utilisation de Docker Compose (recommandé)
-```shell
-# Télécharger le projet
-git clone https://github.com/Calcium-Ion/new-api.git
-cd new-api
-# Modifier docker-compose.yml si nécessaire
-# Démarrer
-docker-compose up -d
-```
-
-#### Utilisation directe de l'image Docker
-```shell
-# Utilisation de SQLite
-docker run --name new-api -d --restart always -p 3000:3000 -e TZ=Asia/Shanghai -v /home/ubuntu/data/new-api:/data calciumion/new-api:latest
-
-# Utilisation de MySQL
-docker run --name new-api -d --restart always -p 3000:3000 -e SQL_DSN="root:123456@tcp(localhost:3306)/oneapi" -e TZ=Asia/Shanghai -v /home/ubuntu/data/new-api:/data calciumion/new-api:latest
-```
-
-## Nouvelle tentative de canal et cache
-La fonctionnalité de nouvelle tentative de canal a été implémentée, vous pouvez définir le nombre de tentatives dans `Paramètres->Paramètres de fonctionnement->Paramètres généraux`. Il est **recommandé d'activer la mise en cache**.
-
-### Méthode de configuration du cache
-1. `REDIS_CONN_STRING` : Définir Redis comme cache
-2. `MEMORY_CACHE_ENABLED` : Activer le cache mémoire (pas besoin de le définir manuellement si Redis est défini)
-
-## Documentation de l'API
-
-Pour une documentation détaillée de l'API, veuillez vous référer à [Documentation de l'API](https://docs.newapi.pro/api) :
-
-- [API de discussion](https://docs.newapi.pro/api/openai-chat)
-- [API d'image](https://docs.newapi.pro/api/openai-image)
-- [API de rerank](https://docs.newapi.pro/api/jinaai-rerank)
-- [API en temps réel](https://docs.newapi.pro/api/openai-realtime)
-- [API de discussion Claude (messages)](https://docs.newapi.pro/api/anthropic-chat)
-
-## Projets connexes
-- [One API](https://github.com/songquanpeng/one-api) : Projet original
-- [Midjourney-Proxy](https://github.com/novicezk/midjourney-proxy) : Prise en charge de l'interface Midjourney
-- [chatnio](https://github.com/Deeptrain-Community/chatnio) : Solution B/C unique d'IA de nouvelle génération
-- [neko-api-key-tool](https://github.com/Calcium-Ion/neko-api-key-tool) : Interroger le quota d'utilisation avec une clé
-
-Autres projets basés sur New API :
-- [new-api-horizon](https://github.com/Calcium-Ion/new-api-horizon) : Version optimisée hautes performances de New API
-- [VoAPI](https://github.com/VoAPI/VoAPI) : Version embellie du frontend basée sur New API
-
-## Aide et support
-
-Si vous avez des questions, veuillez vous référer à [Aide et support](https://docs.newapi.pro/support) :
-- [Interaction avec la communauté](https://docs.newapi.pro/support/community-interaction)
-- [Commentaires sur les problèmes](https://docs.newapi.pro/support/feedback-issues)
-- [FAQ](https://docs.newapi.pro/support/faq)
-
-## 🌟 Historique des étoiles
-
-[![Graphique de l'historique des étoiles](https://api.star-history.com/svg?repos=Calcium-Ion/new-api&type=Date)](https://star-history.com/#Calcium-Ion/new-api&Date)

new-api/README.md

@@ -1,219 +0,0 @@
-<p align="right">
-   <strong>中文</strong> | <a href="./README.en.md">English</a> | <a href="./README.fr.md">Français</a>
-</p>
-<div align="center">
-
-![new-api](/web/public/logo.png)
-
-# New API
-
-🍥新一代大模型网关与AI资产管理系统
-
-<a href="https://trendshift.io/repositories/8227" target="_blank"><img src="https://trendshift.io/api/badge/repositories/8227" alt="Calcium-Ion%2Fnew-api | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
-
-<p align="center">
-  <a href="https://raw.githubusercontent.com/Calcium-Ion/new-api/main/LICENSE">
-    <img src="https://img.shields.io/github/license/Calcium-Ion/new-api?color=brightgreen" alt="license">
-  </a>
-  <a href="https://github.com/Calcium-Ion/new-api/releases/latest">
-    <img src="https://img.shields.io/github/v/release/Calcium-Ion/new-api?color=brightgreen&include_prereleases" alt="release">
-  </a>
-  <a href="https://github.com/users/Calcium-Ion/packages/container/package/new-api">
-    <img src="https://img.shields.io/badge/docker-ghcr.io-blue" alt="docker">
-  </a>
-  <a href="https://hub.docker.com/r/CalciumIon/new-api">
-    <img src="https://img.shields.io/badge/docker-dockerHub-blue" alt="docker">
-  </a>
-  <a href="https://goreportcard.com/report/github.com/Calcium-Ion/new-api">
-    <img src="https://goreportcard.com/badge/github.com/Calcium-Ion/new-api" alt="GoReportCard">
-  </a>
-</p>
-</div>
-
-## 📝 项目说明
-
-> [!NOTE]  
-> 本项目为开源项目，在[One API](https://github.com/songquanpeng/one-api)的基础上进行二次开发
-
-> [!IMPORTANT]  
-> - 本项目仅供个人学习使用，不保证稳定性，且不提供任何技术支持。
-> - 使用者必须在遵循 OpenAI 的[使用条款](https://openai.com/policies/terms-of-use)以及**法律法规**的情况下使用，不得用于非法用途。
-> - 根据[《生成式人工智能服务管理暂行办法》](http://www.cac.gov.cn/2023-07/13/c_1690898327029107.htm)的要求，请勿对中国地区公众提供一切未经备案的生成式人工智能服务。
-
-<h2>🤝 我们信任的合作伙伴</h2>
-<p id="premium-sponsors">&nbsp;</p>
-<p align="center"><strong>排名不分先后</strong></p>
-<p align="center">
-  <a href="https://www.cherry-ai.com/" target=_blank><img
-    src="./docs/images/cherry-studio.png" alt="Cherry Studio" height="120"
-  /></a>
-  <a href="https://bda.pku.edu.cn/" target=_blank><img
-    src="./docs/images/pku.png" alt="北京大学" height="120"
-  /></a>
-  <a href="https://www.compshare.cn/?ytag=GPU_yy_gh_newapi" target=_blank><img
-    src="./docs/images/ucloud.png" alt="UCloud 优刻得" height="120"
-  /></a>
-  <a href="https://www.aliyun.com/" target=_blank><img
-    src="./docs/images/aliyun.png" alt="阿里云" height="120"
-  /></a>
-  <a href="https://io.net/" target=_blank><img
-    src="./docs/images/io-net.png" alt="IO.NET" height="120"
-  /></a>
-</p>
-<p>&nbsp;</p>
-
-## 📚 文档
-
-详细文档请访问我们的官方Wiki：[https://docs.newapi.pro/](https://docs.newapi.pro/)
-
-也可访问AI生成的DeepWiki:
-[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/QuantumNous/new-api)
-
-## ✨ 主要特性
-
-New API提供了丰富的功能，详细特性请参考[特性说明](https://docs.newapi.pro/wiki/features-introduction)：
-
-1. 🎨 全新的UI界面
-2. 🌍 多语言支持
-3. 💰 支持在线充值功能（易支付）
-4. 🔍 支持用key查询使用额度（配合[neko-api-key-tool](https://github.com/Calcium-Ion/neko-api-key-tool)）
-5. 🔄 兼容原版One API的数据库
-6. 💵 支持模型按次数收费
-7. ⚖️ 支持渠道加权随机
-8. 📈 数据看板（控制台）
-9. 🔒 令牌分组、模型限制
-10. 🤖 支持更多授权登陆方式（LinuxDO,Telegram、OIDC）
-11. 🔄 支持Rerank模型（Cohere和Jina），[接口文档](https://docs.newapi.pro/api/jinaai-rerank)
-12. ⚡ 支持OpenAI Realtime API（包括Azure渠道），[接口文档](https://docs.newapi.pro/api/openai-realtime)
-13. ⚡ 支持Claude Messages 格式，[接口文档](https://docs.newapi.pro/api/anthropic-chat)
-14. 支持使用路由/chat2link进入聊天界面
-15. 🧠 支持通过模型名称后缀设置 reasoning effort：
-    1. OpenAI o系列模型
-        - 添加后缀 `-high` 设置为 high reasoning effort (例如: `o3-mini-high`)
-        - 添加后缀 `-medium` 设置为 medium reasoning effort (例如: `o3-mini-medium`)
-        - 添加后缀 `-low` 设置为 low reasoning effort (例如: `o3-mini-low`)
-    2. Claude 思考模型
-        - 添加后缀 `-thinking` 启用思考模式 (例如: `claude-3-7-sonnet-20250219-thinking`)
-16. 🔄 思考转内容功能
-17. 🔄 针对用户的模型限流功能
-18. 🔄 请求格式转换功能，支持以下三种格式转换：
-    1. OpenAI Chat Completions => Claude Messages
-    2. Clade Messages => OpenAI Chat Completions (可用于Claude Code调用第三方���型)
-    3. OpenAI Chat Completions => Gemini Chat
-19. 💰 缓存计费支持，开启后可以在缓存命中时按照设定的比例计费：
-    1. 在 `系统设置-运营设置` 中设置 `提示缓存倍率` 选项
-    2. 在渠道中设置 `提示缓存倍率`，范围 0-1，例如设置为 0.5 表示缓存命中时按照 50% 计费
-    3. 支持的渠道：
-        - [x] OpenAI
-        - [x] Azure
-        - [x] DeepSeek
-        - [x] Claude
-
-## 模型支持
-
-此版本支持多种模型，详情请参考[接口文档-中继接口](https://docs.newapi.pro/api)：
-
-1. 第三方模型 **gpts** （gpt-4-gizmo-*）
-2. 第三方渠道[Midjourney-Proxy(Plus)](https://github.com/novicezk/midjourney-proxy)接口，[接口文档](https://docs.newapi.pro/api/midjourney-proxy-image)
-3. 第三方渠道[Suno API](https://github.com/Suno-API/Suno-API)接口，[接口文档](https://docs.newapi.pro/api/suno-music)
-4. 自定义渠道，支持填入完整调用地址
-5. Rerank模型（[Cohere](https://cohere.ai/)和[Jina](https://jina.ai/)），[接口文档](https://docs.newapi.pro/api/jinaai-rerank)
-6. Claude Messages 格式，[接口文档](https://docs.newapi.pro/api/anthropic-chat)
-7. Dify，当前仅支持chatflow
-
-## 环境变量配置
-
-详细配置说明请参考[安装指南-环境变量配置](https://docs.newapi.pro/installation/environment-variables)：
-
-- `GENERATE_DEFAULT_TOKEN`：是否为新注册用户生成初始令牌，默认为 `false`
-- `STREAMING_TIMEOUT`：流式回复超时时间，默认300秒
-- `DIFY_DEBUG`：Dify渠道是否输出工作流和节点信息，默认 `true`
-- `FORCE_STREAM_OPTION`：是否覆盖客户端stream_options参数，默认 `true`
-- `GET_MEDIA_TOKEN`：是否统计图片token，默认 `true`
-- `GET_MEDIA_TOKEN_NOT_STREAM`：非流情况下是否统计图片token，默认 `true`
-- `UPDATE_TASK`：是否更新异步任务（Midjourney、Suno），默认 `true`
-- `COHERE_SAFETY_SETTING`：Cohere模型安全设置，可选值为 `NONE`, `CONTEXTUAL`, `STRICT`，默认 `NONE`
-- `GEMINI_VISION_MAX_IMAGE_NUM`：Gemini模型最大图片数量，默认 `16`
-- `MAX_FILE_DOWNLOAD_MB`: 最大文件下载大小，单位MB，默认 `20`
-- `CRYPTO_SECRET`：加密密钥，用于加密数据库内容
-- `AZURE_DEFAULT_API_VERSION`：Azure渠道默认API版本，默认 `2025-04-01-preview`
-- `NOTIFICATION_LIMIT_DURATION_MINUTE`：通知限制持续时间，默认 `10`分钟
-- `NOTIFY_LIMIT_COUNT`：用户通知在指定持续时间内的最大数量，默认 `2`
-- `ERROR_LOG_ENABLED=true`: 是否记录并显示错误日志，默认`false`
-
-## 部署
-
-详细部署指南请参考[安装指南-部署方式](https://docs.newapi.pro/installation)：
-
-> [!TIP]
-> 最新版Docker镜像：`calciumion/new-api:latest`  
-
-### 多机部署注意事项
-- 必须设置环境变量 `SESSION_SECRET`，否则会导致多机部署时登录状态不一致
-- 如果公用Redis，必须设置 `CRYPTO_SECRET`，否则会导致多机部署时Redis内容无法获取
-
-### 部署要求
-- 本地数据库（默认）：SQLite（Docker部署必须挂载`/data`目录）
-- 远程数据库：MySQL版本 >= 5.7.8，PgSQL版本 >= 9.6
-
-### 部署方式
-
-#### 使用宝塔面板Docker功能部署
-安装宝塔面板（**9.2.0版本**及以上），在应用商店中找到**New-API**安装即可。
-[图文教程](./docs/BT.md)
-
-#### 使用Docker Compose部署（推荐）
-```shell
-# 下载项目
-git clone https://github.com/Calcium-Ion/new-api.git
-cd new-api
-# 按需编辑docker-compose.yml
-# 启动
-docker-compose up -d
-```
-
-#### 直接使用Docker镜像
-```shell
-# 使用SQLite
-docker run --name new-api -d --restart always -p 3000:3000 -e TZ=Asia/Shanghai -v /home/ubuntu/data/new-api:/data calciumion/new-api:latest
-
-# 使用MySQL
-docker run --name new-api -d --restart always -p 3000:3000 -e SQL_DSN="root:123456@tcp(localhost:3306)/oneapi" -e TZ=Asia/Shanghai -v /home/ubuntu/data/new-api:/data calciumion/new-api:latest
-```
-
-## 渠道重试与缓存
-渠道重试功能已经实现，可以在`设置->运营设置->通用设置`设置重试次数，**建议开启缓存**功能。
-
-### 缓存设置方法
-1. `REDIS_CONN_STRING`：设置Redis作为缓存
-2. `MEMORY_CACHE_ENABLED`：启用内存缓存（设置了Redis则无需手动设置）
-
-## 接口文档
-
-详细接口文档请参考[接口文档](https://docs.newapi.pro/api)：
-
-- [聊天接口（Chat）](https://docs.newapi.pro/api/openai-chat)
-- [图像接口（Image）](https://docs.newapi.pro/api/openai-image)
-- [重排序接口（Rerank）](https://docs.newapi.pro/api/jinaai-rerank)
-- [实时对话接口（Realtime）](https://docs.newapi.pro/api/openai-realtime)
-- [Claude聊天接口（messages）](https://docs.newapi.pro/api/anthropic-chat)
-
-## 相关项目
-- [One API](https://github.com/songquanpeng/one-api)：原版项目
-- [Midjourney-Proxy](https://github.com/novicezk/midjourney-proxy)：Midjourney接口支持
-- [chatnio](https://github.com/Deeptrain-Community/chatnio)：下一代AI一站式B/C端解决方案
-- [neko-api-key-tool](https://github.com/Calcium-Ion/neko-api-key-tool)：用key查询使用额度
-
-其他基于New API的项目：
-- [new-api-horizon](https://github.com/Calcium-Ion/new-api-horizon)：New API高性能优化版
-
-## 帮助支持
-
-如有问题，请参考[帮助支持](https://docs.newapi.pro/support)：
-- [社区交流](https://docs.newapi.pro/support/community-interaction)
-- [反馈问题](https://docs.newapi.pro/support/feedback-issues)
-- [常见问题](https://docs.newapi.pro/support/faq)
-
-## 🌟 Star History
-
-[![Star History Chart](https://api.star-history.com/svg?repos=Calcium-Ion/new-api&type=Date)](https://star-history.com/#Calcium-Ion/new-api&Date)

new-api/bin/migration_v0.2-v0.3.sql

@@ -1,6 +0,0 @@
-UPDATE users
-SET quota = quota + (
-    SELECT SUM(remain_quota)
-    FROM tokens
-    WHERE tokens.user_id = users.id
-)

new-api/bin/migration_v0.3-v0.4.sql

@@ -1,17 +0,0 @@
-INSERT INTO abilities (`group`, model, channel_id, enabled)
-SELECT c.`group`, m.model, c.id, 1
-FROM channels c
-CROSS JOIN (
-    SELECT 'gpt-3.5-turbo' AS model UNION ALL
-    SELECT 'gpt-3.5-turbo-0301' AS model UNION ALL
-    SELECT 'gpt-4' AS model UNION ALL
-    SELECT 'gpt-4-0314' AS model
-) AS m
-WHERE c.status = 1
-  AND NOT EXISTS (
-    SELECT 1
-    FROM abilities a
-    WHERE a.`group` = c.`group`
-      AND a.model = m.model
-      AND a.channel_id = c.id
-);

new-api/bin/time_test.sh

@@ -1,40 +0,0 @@
-#!/bin/bash
-
-if [ $# -lt 3 ]; then
-  echo "Usage: time_test.sh <domain> <key> <count> [<model>]"
-  exit 1
-fi
-
-domain=$1
-key=$2
-count=$3
-model=${4:-"gpt-3.5-turbo"} # 设置默认模型为 gpt-3.5-turbo
-
-total_time=0
-times=()
-
-for ((i=1; i<=count; i++)); do
-  result=$(curl -o /dev/null -s -w "%{http_code} %{time_total}\\n" \
-           https://"$domain"/v1/chat/completions \
-           -H "Content-Type: application/json" \
-           -H "Authorization: Bearer $key" \
-           -d '{"messages": [{"content": "echo hi", "role": "user"}], "model": "'"$model"'", "stream": false, "max_tokens": 1}')
-  http_code=$(echo "$result" | awk '{print $1}')
-  time=$(echo "$result" | awk '{print $2}')
-  echo "HTTP status code: $http_code, Time taken: $time"
-  total_time=$(bc <<< "$total_time + $time")
-  times+=("$time")
-done
-
-average_time=$(echo "scale=4; $total_time / $count" | bc)
-
-sum_of_squares=0
-for time in "${times[@]}"; do
-  difference=$(echo "scale=4; $time - $average_time" | bc)
-  square=$(echo "scale=4; $difference * $difference" | bc)
-  sum_of_squares=$(echo "scale=4; $sum_of_squares + $square" | bc)
-done
-
-standard_deviation=$(echo "scale=4; sqrt($sum_of_squares / $count)" | bc)
-
-echo "Average time: $average_time±$standard_deviation"

new-api/common/api_type.go

@@ -1,77 +0,0 @@
-package common
-
-import "one-api/constant"
-
-func ChannelType2APIType(channelType int) (int, bool) {
-	apiType := -1
-	switch channelType {
-	case constant.ChannelTypeOpenAI:
-		apiType = constant.APITypeOpenAI
-	case constant.ChannelTypeAnthropic:
-		apiType = constant.APITypeAnthropic
-	case constant.ChannelTypeBaidu:
-		apiType = constant.APITypeBaidu
-	case constant.ChannelTypePaLM:
-		apiType = constant.APITypePaLM
-	case constant.ChannelTypeZhipu:
-		apiType = constant.APITypeZhipu
-	case constant.ChannelTypeAli:
-		apiType = constant.APITypeAli
-	case constant.ChannelTypeXunfei:
-		apiType = constant.APITypeXunfei
-	case constant.ChannelTypeAIProxyLibrary:
-		apiType = constant.APITypeAIProxyLibrary
-	case constant.ChannelTypeTencent:
-		apiType = constant.APITypeTencent
-	case constant.ChannelTypeGemini:
-		apiType = constant.APITypeGemini
-	case constant.ChannelTypeZhipu_v4:
-		apiType = constant.APITypeZhipuV4
-	case constant.ChannelTypeOllama:
-		apiType = constant.APITypeOllama
-	case constant.ChannelTypePerplexity:
-		apiType = constant.APITypePerplexity
-	case constant.ChannelTypeAws:
-		apiType = constant.APITypeAws
-	case constant.ChannelTypeCohere:
-		apiType = constant.APITypeCohere
-	case constant.ChannelTypeDify:
-		apiType = constant.APITypeDify
-	case constant.ChannelTypeJina:
-		apiType = constant.APITypeJina
-	case constant.ChannelCloudflare:
-		apiType = constant.APITypeCloudflare
-	case constant.ChannelTypeSiliconFlow:
-		apiType = constant.APITypeSiliconFlow
-	case constant.ChannelTypeVertexAi:
-		apiType = constant.APITypeVertexAi
-	case constant.ChannelTypeMistral:
-		apiType = constant.APITypeMistral
-	case constant.ChannelTypeDeepSeek:
-		apiType = constant.APITypeDeepSeek
-	case constant.ChannelTypeMokaAI:
-		apiType = constant.APITypeMokaAI
-	case constant.ChannelTypeVolcEngine:
-		apiType = constant.APITypeVolcEngine
-	case constant.ChannelTypeBaiduV2:
-		apiType = constant.APITypeBaiduV2
-	case constant.ChannelTypeOpenRouter:
-		apiType = constant.APITypeOpenRouter
-	case constant.ChannelTypeXinference:
-		apiType = constant.APITypeXinference
-	case constant.ChannelTypeXai:
-		apiType = constant.APITypeXai
-	case constant.ChannelTypeCoze:
-		apiType = constant.APITypeCoze
-	case constant.ChannelTypeJimeng:
-		apiType = constant.APITypeJimeng
-	case constant.ChannelTypeMoonshot:
-		apiType = constant.APITypeMoonshot
-	case constant.ChannelTypeSubmodel:
-		apiType = constant.APITypeSubmodel
-	}
-	if apiType == -1 {
-		return constant.APITypeOpenAI, false
-	}
-	return apiType, true
-}

new-api/common/constants.go

@@ -1,202 +0,0 @@
-package common
-
-import (
-	//"os"
-	//"strconv"
-	"sync"
-	"time"
-
-	"github.com/google/uuid"
-)
-
-var StartTime = time.Now().Unix() // unit: second
-var Version = "v0.0.0"            // this hard coding will be replaced automatically when building, no need to manually change
-var SystemName = "New API"
-var Footer = ""
-var Logo = ""
-var TopUpLink = ""
-
-// var ChatLink = ""
-// var ChatLink2 = ""
-var QuotaPerUnit = 500 * 1000.0 // $0.002 / 1K tokens
-var DisplayInCurrencyEnabled = true
-var DisplayTokenStatEnabled = true
-var DrawingEnabled = true
-var TaskEnabled = true
-var DataExportEnabled = true
-var DataExportInterval = 5         // unit: minute
-var DataExportDefaultTime = "hour" // unit: minute
-var DefaultCollapseSidebar = false // default value of collapse sidebar
-
-// Any options with "Secret", "Token" in its key won't be return by GetOptions
-
-var SessionSecret = uuid.New().String()
-var CryptoSecret = uuid.New().String()
-
-var OptionMap map[string]string
-var OptionMapRWMutex sync.RWMutex
-
-var ItemsPerPage = 10
-var MaxRecentItems = 100
-
-var PasswordLoginEnabled = true
-var PasswordRegisterEnabled = true
-var EmailVerificationEnabled = false
-var GitHubOAuthEnabled = false
-var LinuxDOOAuthEnabled = false
-var WeChatAuthEnabled = false
-var TelegramOAuthEnabled = false
-var TurnstileCheckEnabled = false
-var RegisterEnabled = true
-
-var EmailDomainRestrictionEnabled = false // 是否启用邮箱域名限制
-var EmailAliasRestrictionEnabled = false  // 是否启用邮箱别名限制
-var EmailDomainWhitelist = []string{
-	"gmail.com",
-	"163.com",
-	"126.com",
-	"qq.com",
-	"outlook.com",
-	"hotmail.com",
-	"icloud.com",
-	"yahoo.com",
-	"foxmail.com",
-}
-var EmailLoginAuthServerList = []string{
-	"smtp.sendcloud.net",
-	"smtp.azurecomm.net",
-}
-
-var DebugEnabled bool
-var MemoryCacheEnabled bool
-
-var LogConsumeEnabled = true
-
-var SMTPServer = ""
-var SMTPPort = 587
-var SMTPSSLEnabled = false
-var SMTPAccount = ""
-var SMTPFrom = ""
-var SMTPToken = ""
-
-var GitHubClientId = ""
-var GitHubClientSecret = ""
-var LinuxDOClientId = ""
-var LinuxDOClientSecret = ""
-var LinuxDOMinimumTrustLevel = 0
-
-var WeChatServerAddress = ""
-var WeChatServerToken = ""
-var WeChatAccountQRCodeImageURL = ""
-
-var TurnstileSiteKey = ""
-var TurnstileSecretKey = ""
-
-var TelegramBotToken = ""
-var TelegramBotName = ""
-
-var QuotaForNewUser = 0
-var QuotaForInviter = 0
-var QuotaForInvitee = 0
-var ChannelDisableThreshold = 5.0
-var AutomaticDisableChannelEnabled = false
-var AutomaticEnableChannelEnabled = false
-var QuotaRemindThreshold = 1000
-var PreConsumedQuota = 500
-
-var RetryTimes = 0
-
-//var RootUserEmail = ""
-
-var IsMasterNode bool
-
-var requestInterval int
-var RequestInterval time.Duration
-
-var SyncFrequency int // unit is second
-
-var BatchUpdateEnabled = false
-var BatchUpdateInterval int
-
-var RelayTimeout int // unit is second
-
-var GeminiSafetySetting string
-
-// https://docs.cohere.com/docs/safety-modes Type; NONE/CONTEXTUAL/STRICT
-var CohereSafetySetting string
-
-const (
-	RequestIdKey = "X-Oneapi-Request-Id"
-)
-
-const (
-	RoleGuestUser  = 0
-	RoleCommonUser = 1
-	RoleAdminUser  = 10
-	RoleRootUser   = 100
-)
-
-func IsValidateRole(role int) bool {
-	return role == RoleGuestUser || role == RoleCommonUser || role == RoleAdminUser || role == RoleRootUser
-}
-
-var (
-	FileUploadPermission    = RoleGuestUser
-	FileDownloadPermission  = RoleGuestUser
-	ImageUploadPermission   = RoleGuestUser
-	ImageDownloadPermission = RoleGuestUser
-)
-
-// All duration's unit is seconds
-// Shouldn't larger then RateLimitKeyExpirationDuration
-var (
-	GlobalApiRateLimitEnable   bool
-	GlobalApiRateLimitNum      int
-	GlobalApiRateLimitDuration int64
-
-	GlobalWebRateLimitEnable   bool
-	GlobalWebRateLimitNum      int
-	GlobalWebRateLimitDuration int64
-
-	UploadRateLimitNum            = 10
-	UploadRateLimitDuration int64 = 60
-
-	DownloadRateLimitNum            = 10
-	DownloadRateLimitDuration int64 = 60
-
-	CriticalRateLimitNum            = 20
-	CriticalRateLimitDuration int64 = 20 * 60
-)
-
-var RateLimitKeyExpirationDuration = 20 * time.Minute
-
-const (
-	UserStatusEnabled  = 1 // don't use 0, 0 is the default value!
-	UserStatusDisabled = 2 // also don't use 0
-)
-
-const (
-	TokenStatusEnabled   = 1 // don't use 0, 0 is the default value!
-	TokenStatusDisabled  = 2 // also don't use 0
-	TokenStatusExpired   = 3
-	TokenStatusExhausted = 4
-)
-
-const (
-	RedemptionCodeStatusEnabled  = 1 // don't use 0, 0 is the default value!
-	RedemptionCodeStatusDisabled = 2 // also don't use 0
-	RedemptionCodeStatusUsed     = 3 // also don't use 0
-)
-
-const (
-	ChannelStatusUnknown          = 0
-	ChannelStatusEnabled          = 1 // don't use 0, 0 is the default value!
-	ChannelStatusManuallyDisabled = 2 // also don't use 0
-	ChannelStatusAutoDisabled     = 3
-)
-
-const (
-	TopUpStatusPending = "pending"
-	TopUpStatusSuccess = "success"
-	TopUpStatusExpired = "expired"
-)

new-api/common/copy.go

@@ -1,19 +0,0 @@
-package common
-
-import (
-	"fmt"
-
-	"github.com/jinzhu/copier"
-)
-
-func DeepCopy[T any](src *T) (*T, error) {
-	if src == nil {
-		return nil, fmt.Errorf("copy source cannot be nil")
-	}
-	var dst T
-	err := copier.CopyWithOption(&dst, src, copier.Option{DeepCopy: true, IgnoreEmpty: true})
-	if err != nil {
-		return nil, err
-	}
-	return &dst, nil
-}

new-api/common/crypto.go

@@ -1,31 +0,0 @@
-package common
-
-import (
-	"crypto/hmac"
-	"crypto/sha256"
-	"encoding/hex"
-	"golang.org/x/crypto/bcrypt"
-)
-
-func GenerateHMACWithKey(key []byte, data string) string {
-	h := hmac.New(sha256.New, key)
-	h.Write([]byte(data))
-	return hex.EncodeToString(h.Sum(nil))
-}
-
-func GenerateHMAC(data string) string {
-	h := hmac.New(sha256.New, []byte(CryptoSecret))
-	h.Write([]byte(data))
-	return hex.EncodeToString(h.Sum(nil))
-}
-
-func Password2Hash(password string) (string, error) {
-	passwordBytes := []byte(password)
-	hashedPassword, err := bcrypt.GenerateFromPassword(passwordBytes, bcrypt.DefaultCost)
-	return string(hashedPassword), err
-}
-
-func ValidatePasswordAndHash(password string, hash string) bool {
-	err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
-	return err == nil
-}

new-api/common/custom-event.go

@@ -1,87 +0,0 @@
-// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
-// Use of this source code is governed by a MIT style
-// license that can be found in the LICENSE file.
-
-package common
-
-import (
-	"fmt"
-	"io"
-	"net/http"
-	"strings"
-	"sync"
-)
-
-type stringWriter interface {
-	io.Writer
-	writeString(string) (int, error)
-}
-
-type stringWrapper struct {
-	io.Writer
-}
-
-func (w stringWrapper) writeString(str string) (int, error) {
-	return w.Writer.Write([]byte(str))
-}
-
-func checkWriter(writer io.Writer) stringWriter {
-	if w, ok := writer.(stringWriter); ok {
-		return w
-	} else {
-		return stringWrapper{writer}
-	}
-}
-
-// Server-Sent Events
-// W3C Working Draft 29 October 2009
-// http://www.w3.org/TR/2009/WD-eventsource-20091029/
-
-var contentType = []string{"text/event-stream"}
-var noCache = []string{"no-cache"}
-
-var fieldReplacer = strings.NewReplacer(
-	"\n", "\\n",
-	"\r", "\\r")
-
-var dataReplacer = strings.NewReplacer(
-	"\n", "\n",
-	"\r", "\\r")
-
-type CustomEvent struct {
-	Event string
-	Id    string
-	Retry uint
-	Data  interface{}
-
-	Mutex sync.Mutex
-}
-
-func encode(writer io.Writer, event CustomEvent) error {
-	w := checkWriter(writer)
-	return writeData(w, event.Data)
-}
-
-func writeData(w stringWriter, data interface{}) error {
-	dataReplacer.WriteString(w, fmt.Sprint(data))
-	if strings.HasPrefix(data.(string), "data") {
-		w.writeString("\n\n")
-	}
-	return nil
-}
-
-func (r CustomEvent) Render(w http.ResponseWriter) error {
-	r.WriteContentType(w)
-	return encode(w, r)
-}
-
-func (r CustomEvent) WriteContentType(w http.ResponseWriter) {
-	r.Mutex.Lock()
-	defer r.Mutex.Unlock()
-	header := w.Header()
-	header["Content-Type"] = contentType
-
-	if _, exist := header["Cache-Control"]; !exist {
-		header["Cache-Control"] = noCache
-	}
-}

new-api/common/database.go

@@ -1,15 +0,0 @@
-package common
-
-const (
-	DatabaseTypeMySQL      = "mysql"
-	DatabaseTypeSQLite     = "sqlite"
-	DatabaseTypePostgreSQL = "postgres"
-)
-
-var UsingSQLite = false
-var UsingPostgreSQL = false
-var LogSqlType = DatabaseTypeSQLite // Default to SQLite for logging SQL queries
-var UsingMySQL = false
-var UsingClickHouse = false
-
-var SQLitePath = "one-api.db?_busy_timeout=30000"

new-api/common/email-outlook-auth.go

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

new-api/common/email.go

@@ -1,90 +0,0 @@
-package common
-
-import (
-	"crypto/tls"
-	"encoding/base64"
-	"fmt"
-	"net/smtp"
-	"slices"
-	"strings"
-	"time"
-)
-
-func generateMessageID() (string, error) {
-	split := strings.Split(SMTPFrom, "@")
-	if len(split) < 2 {
-		return "", fmt.Errorf("invalid SMTP account")
-	}
-	domain := strings.Split(SMTPFrom, "@")[1]
-	return fmt.Sprintf("<%d.%s@%s>", time.Now().UnixNano(), GetRandomString(12), domain), nil
-}
-
-func SendEmail(subject string, receiver string, content string) error {
-	if SMTPFrom == "" { // for compatibility
-		SMTPFrom = SMTPAccount
-	}
-	id, err2 := generateMessageID()
-	if err2 != nil {
-		return err2
-	}
-	if SMTPServer == "" && SMTPAccount == "" {
-		return fmt.Errorf("SMTP 服务器未配置")
-	}
-	encodedSubject := fmt.Sprintf("=?UTF-8?B?%s?=", base64.StdEncoding.EncodeToString([]byte(subject)))
-	mail := []byte(fmt.Sprintf("To: %s\r\n"+
-		"From: %s<%s>\r\n"+
-		"Subject: %s\r\n"+
-		"Date: %s\r\n"+
-		"Message-ID: %s\r\n"+ // 添加 Message-ID 头
-		"Content-Type: text/html; charset=UTF-8\r\n\r\n%s\r\n",
-		receiver, SystemName, SMTPFrom, encodedSubject, time.Now().Format(time.RFC1123Z), id, content))
-	auth := smtp.PlainAuth("", SMTPAccount, SMTPToken, SMTPServer)
-	addr := fmt.Sprintf("%s:%d", SMTPServer, SMTPPort)
-	to := strings.Split(receiver, ";")
-	var err error
-	if SMTPPort == 465 || SMTPSSLEnabled {
-		tlsConfig := &tls.Config{
-			InsecureSkipVerify: true,
-			ServerName:         SMTPServer,
-		}
-		conn, err := tls.Dial("tcp", fmt.Sprintf("%s:%d", SMTPServer, SMTPPort), tlsConfig)
-		if err != nil {
-			return err
-		}
-		client, err := smtp.NewClient(conn, SMTPServer)
-		if err != nil {
-			return err
-		}
-		defer client.Close()
-		if err = client.Auth(auth); err != nil {
-			return err
-		}
-		if err = client.Mail(SMTPFrom); err != nil {
-			return err
-		}
-		receiverEmails := strings.Split(receiver, ";")
-		for _, receiver := range receiverEmails {
-			if err = client.Rcpt(receiver); err != nil {
-				return err
-			}
-		}
-		w, err := client.Data()
-		if err != nil {
-			return err
-		}
-		_, err = w.Write(mail)
-		if err != nil {
-			return err
-		}
-		err = w.Close()
-		if err != nil {
-			return err
-		}
-	} else if isOutlookServer(SMTPAccount) || slices.Contains(EmailLoginAuthServerList, SMTPServer) {
-		auth = LoginAuth(SMTPAccount, SMTPToken)
-		err = smtp.SendMail(addr, auth, SMTPFrom, to, mail)
-	} else {
-		err = smtp.SendMail(addr, auth, SMTPFrom, to, mail)
-	}
-	return err
-}

new-api/common/embed-file-system.go

@@ -1,32 +0,0 @@
-package common
-
-import (
-	"embed"
-	"github.com/gin-contrib/static"
-	"io/fs"
-	"net/http"
-)
-
-// Credit: https://github.com/gin-contrib/static/issues/19
-
-type embedFileSystem struct {
-	http.FileSystem
-}
-
-func (e embedFileSystem) Exists(prefix string, path string) bool {
-	_, err := e.Open(path)
-	if err != nil {
-		return false
-	}
-	return true
-}
-
-func EmbedFolder(fsEmbed embed.FS, targetPath string) static.ServeFileSystem {
-	efs, err := fs.Sub(fsEmbed, targetPath)
-	if err != nil {
-		panic(err)
-	}
-	return embedFileSystem{
-		FileSystem: http.FS(efs),
-	}
-}

new-api/common/endpoint_defaults.go

@@ -1,33 +0,0 @@
-package common
-
-import "one-api/constant"
-
-// EndpointInfo 描述单个端点的默认请求信息
-// path: 上游路径
-// method: HTTP 请求方式，例如 POST/GET
-// 目前均为 POST，后续可扩展
-//
-// json 标签用于直接序列化到 API 输出
-// 例如：{"path":"/v1/chat/completions","method":"POST"}
-
-type EndpointInfo struct {
-	Path   string `json:"path"`
-	Method string `json:"method"`
-}
-
-// defaultEndpointInfoMap 保存内置端点的默认 Path 与 Method
-var defaultEndpointInfoMap = map[constant.EndpointType]EndpointInfo{
-	constant.EndpointTypeOpenAI:          {Path: "/v1/chat/completions", Method: "POST"},
-	constant.EndpointTypeOpenAIResponse:  {Path: "/v1/responses", Method: "POST"},
-	constant.EndpointTypeAnthropic:       {Path: "/v1/messages", Method: "POST"},
-	constant.EndpointTypeGemini:          {Path: "/v1beta/models/{model}:generateContent", Method: "POST"},
-	constant.EndpointTypeJinaRerank:      {Path: "/rerank", Method: "POST"},
-	constant.EndpointTypeImageGeneration: {Path: "/v1/images/generations", Method: "POST"},
-	constant.EndpointTypeEmbeddings:      {Path: "/v1/embeddings", Method: "POST"},
-}
-
-// GetDefaultEndpointInfo 返回指定端点类型的默认信息以及是否存在
-func GetDefaultEndpointInfo(et constant.EndpointType) (EndpointInfo, bool) {
-	info, ok := defaultEndpointInfoMap[et]
-	return info, ok
-}

new-api/common/endpoint_type.go

@@ -1,41 +0,0 @@
-package common
-
-import "one-api/constant"
-
-// GetEndpointTypesByChannelType 获取渠道最优先端点类型（所有的渠道都支持 OpenAI 端点）
-func GetEndpointTypesByChannelType(channelType int, modelName string) []constant.EndpointType {
-	var endpointTypes []constant.EndpointType
-	switch channelType {
-	case constant.ChannelTypeJina:
-		endpointTypes = []constant.EndpointType{constant.EndpointTypeJinaRerank}
-	//case constant.ChannelTypeMidjourney, constant.ChannelTypeMidjourneyPlus:
-	//	endpointTypes = []constant.EndpointType{constant.EndpointTypeMidjourney}
-	//case constant.ChannelTypeSunoAPI:
-	//	endpointTypes = []constant.EndpointType{constant.EndpointTypeSuno}
-	//case constant.ChannelTypeKling:
-	//	endpointTypes = []constant.EndpointType{constant.EndpointTypeKling}
-	//case constant.ChannelTypeJimeng:
-	//	endpointTypes = []constant.EndpointType{constant.EndpointTypeJimeng}
-	case constant.ChannelTypeAws:
-		fallthrough
-	case constant.ChannelTypeAnthropic:
-		endpointTypes = []constant.EndpointType{constant.EndpointTypeAnthropic, constant.EndpointTypeOpenAI}
-	case constant.ChannelTypeVertexAi:
-		fallthrough
-	case constant.ChannelTypeGemini:
-		endpointTypes = []constant.EndpointType{constant.EndpointTypeGemini, constant.EndpointTypeOpenAI}
-	case constant.ChannelTypeOpenRouter: // OpenRouter 只支持 OpenAI 端点
-		endpointTypes = []constant.EndpointType{constant.EndpointTypeOpenAI}
-	default:
-		if IsOpenAIResponseOnlyModel(modelName) {
-			endpointTypes = []constant.EndpointType{constant.EndpointTypeOpenAIResponse}
-		} else {
-			endpointTypes = []constant.EndpointType{constant.EndpointTypeOpenAI}
-		}
-	}
-	if IsImageGenerationModel(modelName) {
-		// add to first
-		endpointTypes = append([]constant.EndpointType{constant.EndpointTypeImageGeneration}, endpointTypes...)
-	}
-	return endpointTypes
-}

new-api/common/env.go

@@ -1,38 +0,0 @@
-package common
-
-import (
-	"fmt"
-	"os"
-	"strconv"
-)
-
-func GetEnvOrDefault(env string, defaultValue int) int {
-	if env == "" || os.Getenv(env) == "" {
-		return defaultValue
-	}
-	num, err := strconv.Atoi(os.Getenv(env))
-	if err != nil {
-		SysError(fmt.Sprintf("failed to parse %s: %s, using default value: %d", env, err.Error(), defaultValue))
-		return defaultValue
-	}
-	return num
-}
-
-func GetEnvOrDefaultString(env string, defaultValue string) string {
-	if env == "" || os.Getenv(env) == "" {
-		return defaultValue
-	}
-	return os.Getenv(env)
-}
-
-func GetEnvOrDefaultBool(env string, defaultValue bool) bool {
-	if env == "" || os.Getenv(env) == "" {
-		return defaultValue
-	}
-	b, err := strconv.ParseBool(os.Getenv(env))
-	if err != nil {
-		SysError(fmt.Sprintf("failed to parse %s: %s, using default value: %t", env, err.Error(), defaultValue))
-		return defaultValue
-	}
-	return b
-}

new-api/common/gin.go

@@ -1,115 +0,0 @@
-package common
-
-import (
-	"bytes"
-	"io"
-	"net/http"
-	"one-api/constant"
-	"strings"
-	"time"
-
-	"github.com/gin-gonic/gin"
-)
-
-const KeyRequestBody = "key_request_body"
-
-func GetRequestBody(c *gin.Context) ([]byte, error) {
-	requestBody, _ := c.Get(KeyRequestBody)
-	if requestBody != nil {
-		return requestBody.([]byte), nil
-	}
-	requestBody, err := io.ReadAll(c.Request.Body)
-	if err != nil {
-		return nil, err
-	}
-	_ = c.Request.Body.Close()
-	c.Set(KeyRequestBody, requestBody)
-	return requestBody.([]byte), nil
-}
-
-func UnmarshalBodyReusable(c *gin.Context, v any) error {
-	requestBody, err := GetRequestBody(c)
-	if err != nil {
-		return err
-	}
-	//if DebugEnabled {
-	//	println("UnmarshalBodyReusable request body:", string(requestBody))
-	//}
-	contentType := c.Request.Header.Get("Content-Type")
-	if strings.HasPrefix(contentType, "application/json") {
-		err = Unmarshal(requestBody, &v)
-	} else {
-		// skip for now
-		// TODO: someday non json request have variant model, we will need to implementation this
-	}
-	if err != nil {
-		return err
-	}
-	// Reset request body
-	c.Request.Body = io.NopCloser(bytes.NewBuffer(requestBody))
-	return nil
-}
-
-func SetContextKey(c *gin.Context, key constant.ContextKey, value any) {
-	c.Set(string(key), value)
-}
-
-func GetContextKey(c *gin.Context, key constant.ContextKey) (any, bool) {
-	return c.Get(string(key))
-}
-
-func GetContextKeyString(c *gin.Context, key constant.ContextKey) string {
-	return c.GetString(string(key))
-}
-
-func GetContextKeyInt(c *gin.Context, key constant.ContextKey) int {
-	return c.GetInt(string(key))
-}
-
-func GetContextKeyBool(c *gin.Context, key constant.ContextKey) bool {
-	return c.GetBool(string(key))
-}
-
-func GetContextKeyStringSlice(c *gin.Context, key constant.ContextKey) []string {
-	return c.GetStringSlice(string(key))
-}
-
-func GetContextKeyStringMap(c *gin.Context, key constant.ContextKey) map[string]any {
-	return c.GetStringMap(string(key))
-}
-
-func GetContextKeyTime(c *gin.Context, key constant.ContextKey) time.Time {
-	return c.GetTime(string(key))
-}
-
-func GetContextKeyType[T any](c *gin.Context, key constant.ContextKey) (T, bool) {
-	if value, ok := c.Get(string(key)); ok {
-		if v, ok := value.(T); ok {
-			return v, true
-		}
-	}
-	var t T
-	return t, false
-}
-
-func ApiError(c *gin.Context, err error) {
-	c.JSON(http.StatusOK, gin.H{
-		"success": false,
-		"message": err.Error(),
-	})
-}
-
-func ApiErrorMsg(c *gin.Context, msg string) {
-	c.JSON(http.StatusOK, gin.H{
-		"success": false,
-		"message": msg,
-	})
-}
-
-func ApiSuccess(c *gin.Context, data any) {
-	c.JSON(http.StatusOK, gin.H{
-		"success": true,
-		"message": "",
-		"data":    data,
-	})
-}

new-api/common/go-channel.go

@@ -1,53 +0,0 @@
-package common
-
-import (
-	"time"
-)
-
-func SafeSendBool(ch chan bool, value bool) (closed bool) {
-	defer func() {
-		// Recover from panic if one occured. A panic would mean the channel was closed.
-		if recover() != nil {
-			closed = true
-		}
-	}()
-
-	// This will panic if the channel is closed.
-	ch <- value
-
-	// If the code reaches here, then the channel was not closed.
-	return false
-}
-
-func SafeSendString(ch chan string, value string) (closed bool) {
-	defer func() {
-		// Recover from panic if one occured. A panic would mean the channel was closed.
-		if recover() != nil {
-			closed = true
-		}
-	}()
-
-	// This will panic if the channel is closed.
-	ch <- value
-
-	// If the code reaches here, then the channel was not closed.
-	return false
-}
-
-// SafeSendStringTimeout send, return true, else return false
-func SafeSendStringTimeout(ch chan string, value string, timeout int) (closed bool) {
-	defer func() {
-		// Recover from panic if one occured. A panic would mean the channel was closed.
-		if recover() != nil {
-			closed = false
-		}
-	}()
-
-	// This will panic if the channel is closed.
-	select {
-	case ch <- value:
-		return true
-	case <-time.After(time.Duration(timeout) * time.Second):
-		return false
-	}
-}

new-api/common/gopool.go

@@ -1,24 +0,0 @@
-package common
-
-import (
-	"context"
-	"fmt"
-	"github.com/bytedance/gopkg/util/gopool"
-	"math"
-)
-
-var relayGoPool gopool.Pool
-
-func init() {
-	relayGoPool = gopool.NewPool("gopool.RelayPool", math.MaxInt32, gopool.NewConfig())
-	relayGoPool.SetPanicHandler(func(ctx context.Context, i interface{}) {
-		if stopChan, ok := ctx.Value("stop_chan").(chan bool); ok {
-			SafeSendBool(stopChan, true)
-		}
-		SysError(fmt.Sprintf("panic in gopool.RelayPool: %v", i))
-	})
-}
-
-func RelayCtxGo(ctx context.Context, f func()) {
-	relayGoPool.CtxGo(ctx, f)
-}

new-api/common/hash.go

@@ -1,34 +0,0 @@
-package common
-
-import (
-	"crypto/hmac"
-	"crypto/sha1"
-	"crypto/sha256"
-	"encoding/hex"
-)
-
-func Sha256Raw(data []byte) []byte {
-	h := sha256.New()
-	h.Write(data)
-	return h.Sum(nil)
-}
-
-func Sha1Raw(data []byte) []byte {
-	h := sha1.New()
-	h.Write(data)
-	return h.Sum(nil)
-}
-
-func Sha1(data []byte) string {
-	return hex.EncodeToString(Sha1Raw(data))
-}
-
-func HmacSha256Raw(message, key []byte) []byte {
-	h := hmac.New(sha256.New, key)
-	h.Write(message)
-	return h.Sum(nil)
-}
-
-func HmacSha256(message, key string) string {
-	return hex.EncodeToString(HmacSha256Raw([]byte(message), []byte(key)))
-}

new-api/common/init.go

@@ -1,120 +0,0 @@
-package common
-
-import (
-	"flag"
-	"fmt"
-	"log"
-	"one-api/constant"
-	"os"
-	"path/filepath"
-	"strconv"
-	"time"
-)
-
-var (
-	Port         = flag.Int("port", 3000, "the listening port")
-	PrintVersion = flag.Bool("version", false, "print version and exit")
-	PrintHelp    = flag.Bool("help", false, "print help and exit")
-	LogDir       = flag.String("log-dir", "./logs", "specify the log directory")
-)
-
-func printHelp() {
-	fmt.Println("New API " + Version + " - All in one API service for OpenAI API.")
-	fmt.Println("Copyright (C) 2023 JustSong. All rights reserved.")
-	fmt.Println("GitHub: https://github.com/songquanpeng/one-api")
-	fmt.Println("Usage: one-api [--port <port>] [--log-dir <log directory>] [--version] [--help]")
-}
-
-func InitEnv() {
-	flag.Parse()
-
-	if *PrintVersion {
-		fmt.Println(Version)
-		os.Exit(0)
-	}
-
-	if *PrintHelp {
-		printHelp()
-		os.Exit(0)
-	}
-
-	if os.Getenv("SESSION_SECRET") != "" {
-		ss := os.Getenv("SESSION_SECRET")
-		if ss == "random_string" {
-			log.Println("WARNING: SESSION_SECRET is set to the default value 'random_string', please change it to a random string.")
-			log.Println("警告：SESSION_SECRET被设置为默认值'random_string'，请修改为随机字符串。")
-			log.Fatal("Please set SESSION_SECRET to a random string.")
-		} else {
-			SessionSecret = ss
-		}
-	}
-	if os.Getenv("CRYPTO_SECRET") != "" {
-		CryptoSecret = os.Getenv("CRYPTO_SECRET")
-	} else {
-		CryptoSecret = SessionSecret
-	}
-	if os.Getenv("SQLITE_PATH") != "" {
-		SQLitePath = os.Getenv("SQLITE_PATH")
-	}
-	if *LogDir != "" {
-		var err error
-		*LogDir, err = filepath.Abs(*LogDir)
-		if err != nil {
-			log.Fatal(err)
-		}
-		if _, err := os.Stat(*LogDir); os.IsNotExist(err) {
-			err = os.Mkdir(*LogDir, 0777)
-			if err != nil {
-				log.Fatal(err)
-			}
-		}
-	}
-
-	// Initialize variables from constants.go that were using environment variables
-	DebugEnabled = os.Getenv("DEBUG") == "true"
-	MemoryCacheEnabled = os.Getenv("MEMORY_CACHE_ENABLED") == "true"
-	IsMasterNode = os.Getenv("NODE_TYPE") != "slave"
-
-	// Parse requestInterval and set RequestInterval
-	requestInterval, _ = strconv.Atoi(os.Getenv("POLLING_INTERVAL"))
-	RequestInterval = time.Duration(requestInterval) * time.Second
-
-	// Initialize variables with GetEnvOrDefault
-	SyncFrequency = GetEnvOrDefault("SYNC_FREQUENCY", 60)
-	BatchUpdateInterval = GetEnvOrDefault("BATCH_UPDATE_INTERVAL", 5)
-	RelayTimeout = GetEnvOrDefault("RELAY_TIMEOUT", 0)
-
-	// Initialize string variables with GetEnvOrDefaultString
-	GeminiSafetySetting = GetEnvOrDefaultString("GEMINI_SAFETY_SETTING", "BLOCK_NONE")
-	CohereSafetySetting = GetEnvOrDefaultString("COHERE_SAFETY_SETTING", "NONE")
-
-	// Initialize rate limit variables
-	GlobalApiRateLimitEnable = GetEnvOrDefaultBool("GLOBAL_API_RATE_LIMIT_ENABLE", true)
-	GlobalApiRateLimitNum = GetEnvOrDefault("GLOBAL_API_RATE_LIMIT", 180)
-	GlobalApiRateLimitDuration = int64(GetEnvOrDefault("GLOBAL_API_RATE_LIMIT_DURATION", 180))
-
-	GlobalWebRateLimitEnable = GetEnvOrDefaultBool("GLOBAL_WEB_RATE_LIMIT_ENABLE", true)
-	GlobalWebRateLimitNum = GetEnvOrDefault("GLOBAL_WEB_RATE_LIMIT", 60)
-	GlobalWebRateLimitDuration = int64(GetEnvOrDefault("GLOBAL_WEB_RATE_LIMIT_DURATION", 180))
-
-	initConstantEnv()
-}
-
-func initConstantEnv() {
-	constant.StreamingTimeout = GetEnvOrDefault("STREAMING_TIMEOUT", 300)
-	constant.DifyDebug = GetEnvOrDefaultBool("DIFY_DEBUG", true)
-	constant.MaxFileDownloadMB = GetEnvOrDefault("MAX_FILE_DOWNLOAD_MB", 20)
-	// ForceStreamOption 覆盖请求参数，强制返回usage信息
-	constant.ForceStreamOption = GetEnvOrDefaultBool("FORCE_STREAM_OPTION", true)
-	constant.GetMediaToken = GetEnvOrDefaultBool("GET_MEDIA_TOKEN", true)
-	constant.GetMediaTokenNotStream = GetEnvOrDefaultBool("GET_MEDIA_TOKEN_NOT_STREAM", true)
-	constant.UpdateTask = GetEnvOrDefaultBool("UPDATE_TASK", true)
-	constant.AzureDefaultAPIVersion = GetEnvOrDefaultString("AZURE_DEFAULT_API_VERSION", "2025-04-01-preview")
-	constant.GeminiVisionMaxImageNum = GetEnvOrDefault("GEMINI_VISION_MAX_IMAGE_NUM", 16)
-	constant.NotifyLimitCount = GetEnvOrDefault("NOTIFY_LIMIT_COUNT", 2)
-	constant.NotificationLimitDurationMinute = GetEnvOrDefault("NOTIFICATION_LIMIT_DURATION_MINUTE", 10)
-	// GenerateDefaultToken 是否生成初始令牌，默认关闭。
-	constant.GenerateDefaultToken = GetEnvOrDefaultBool("GENERATE_DEFAULT_TOKEN", false)
-	// 是否启用错误日志
-	constant.ErrorLogEnabled = GetEnvOrDefaultBool("ERROR_LOG_ENABLED", false)
-}

new-api/common/ip.go

@@ -1,22 +0,0 @@
-package common
-
-import "net"
-
-func IsPrivateIP(ip net.IP) bool {
-	if ip.IsLoopback() || ip.IsLinkLocalUnicast() || ip.IsLinkLocalMulticast() {
-		return true
-	}
-
-	private := []net.IPNet{
-		{IP: net.IPv4(10, 0, 0, 0), Mask: net.CIDRMask(8, 32)},
-		{IP: net.IPv4(172, 16, 0, 0), Mask: net.CIDRMask(12, 32)},
-		{IP: net.IPv4(192, 168, 0, 0), Mask: net.CIDRMask(16, 32)},
-	}
-
-	for _, privateNet := range private {
-		if privateNet.Contains(ip) {
-			return true
-		}
-	}
-	return false
-}

new-api/common/json.go

@@ -1,44 +0,0 @@
-package common
-
-import (
-	"bytes"
-	"encoding/json"
-)
-
-func Unmarshal(data []byte, v any) error {
-	return json.Unmarshal(data, v)
-}
-
-func UnmarshalJsonStr(data string, v any) error {
-	return json.Unmarshal(StringToByteSlice(data), v)
-}
-
-func DecodeJson(reader *bytes.Reader, v any) error {
-	return json.NewDecoder(reader).Decode(v)
-}
-
-func Marshal(v any) ([]byte, error) {
-	return json.Marshal(v)
-}
-
-func GetJsonType(data json.RawMessage) string {
-	data = bytes.TrimSpace(data)
-	if len(data) == 0 {
-		return "unknown"
-	}
-	firstChar := bytes.TrimSpace(data)[0]
-	switch firstChar {
-	case '{':
-		return "object"
-	case '[':
-		return "array"
-	case '"':
-		return "string"
-	case 't', 'f':
-		return "boolean"
-	case 'n':
-		return "null"
-	default:
-		return "number"
-	}
-}

new-api/common/limiter/limiter.go

@@ -1,89 +0,0 @@
-package limiter
-
-import (
-	"context"
-	_ "embed"
-	"fmt"
-	"github.com/go-redis/redis/v8"
-	"one-api/common"
-	"sync"
-)
-
-//go:embed lua/rate_limit.lua
-var rateLimitScript string
-
-type RedisLimiter struct {
-	client         *redis.Client
-	limitScriptSHA string
-}
-
-var (
-	instance *RedisLimiter
-	once     sync.Once
-)
-
-func New(ctx context.Context, r *redis.Client) *RedisLimiter {
-	once.Do(func() {
-		// 预加载脚本
-		limitSHA, err := r.ScriptLoad(ctx, rateLimitScript).Result()
-		if err != nil {
-			common.SysLog(fmt.Sprintf("Failed to load rate limit script: %v", err))
-		}
-		instance = &RedisLimiter{
-			client:         r,
-			limitScriptSHA: limitSHA,
-		}
-	})
-
-	return instance
-}
-
-func (rl *RedisLimiter) Allow(ctx context.Context, key string, opts ...Option) (bool, error) {
-	// 默认配置
-	config := &Config{
-		Capacity:  10,
-		Rate:      1,
-		Requested: 1,
-	}
-
-	// 应用选项模式
-	for _, opt := range opts {
-		opt(config)
-	}
-
-	// 执行限流
-	result, err := rl.client.EvalSha(
-		ctx,
-		rl.limitScriptSHA,
-		[]string{key},
-		config.Requested,
-		config.Rate,
-		config.Capacity,
-	).Int()
-
-	if err != nil {
-		return false, fmt.Errorf("rate limit failed: %w", err)
-	}
-	return result == 1, nil
-}
-
-// Config 配置选项模式
-type Config struct {
-	Capacity  int64
-	Rate      int64
-	Requested int64
-}
-
-type Option func(*Config)
-
-func WithCapacity(c int64) Option {
-	return func(cfg *Config) { cfg.Capacity = c }
-}
-
-func WithRate(r int64) Option {
-	return func(cfg *Config) { cfg.Rate = r }
-}
-
-func WithRequested(n int64) Option {
-	return func(cfg *Config) { cfg.Requested = n }
-}

new-api/common/limiter/lua/rate_limit.lua

@@ -1,44 +0,0 @@
--- 令牌桶限流器
--- KEYS[1]: 限流器唯一标识
--- ARGV[1]: 请求令牌数 (通常为1)
--- ARGV[2]: 令牌生成速率 (每秒)
--- ARGV[3]: 桶容量
-
-local key = KEYS[1]
-local requested = tonumber(ARGV[1])
-local rate = tonumber(ARGV[2])
-local capacity = tonumber(ARGV[3])
-
--- 获取当前时间（Redis服务器时间）
-local now = redis.call('TIME')
-local nowInSeconds = tonumber(now[1])
-
--- 获取桶状态
-local bucket = redis.call('HMGET', key, 'tokens', 'last_time')
-local tokens = tonumber(bucket[1])
-local last_time = tonumber(bucket[2])
-
--- 初始化桶（首次请求或过期）
-if not tokens or not last_time then
-    tokens = capacity
-    last_time = nowInSeconds
-else
-    -- 计算新增令牌
-    local elapsed = nowInSeconds - last_time
-    local add_tokens = elapsed * rate
-    tokens = math.min(capacity, tokens + add_tokens)
-    last_time = nowInSeconds
-end
-
--- 判断是否允许请求
-local allowed = false
-if tokens >= requested then
-    tokens = tokens - requested
-    allowed = true
-end
-
----- 更新桶状态并设置过期时间
-redis.call('HMSET', key, 'tokens', tokens, 'last_time', last_time)
---redis.call('EXPIRE', key, math.ceil(capacity / rate) + 60) -- 适当延长过期时间
-
-return allowed and 1 or 0

new-api/common/model.go

@@ -1,42 +0,0 @@
-package common
-
-import "strings"
-
-var (
-	// OpenAIResponseOnlyModels is a list of models that are only available for OpenAI responses.
-	OpenAIResponseOnlyModels = []string{
-		"o3-pro",
-		"o3-deep-research",
-		"o4-mini-deep-research",
-	}
-	ImageGenerationModels = []string{
-		"dall-e-3",
-		"dall-e-2",
-		"gpt-image-1",
-		"prefix:imagen-",
-		"flux-",
-		"flux.1-",
-	}
-)
-
-func IsOpenAIResponseOnlyModel(modelName string) bool {
-	for _, m := range OpenAIResponseOnlyModels {
-		if strings.Contains(modelName, m) {
-			return true
-		}
-	}
-	return false
-}
-
-func IsImageGenerationModel(modelName string) bool {
-	modelName = strings.ToLower(modelName)
-	for _, m := range ImageGenerationModels {
-		if strings.Contains(modelName, m) {
-			return true
-		}
-		if strings.HasPrefix(m, "prefix:") && strings.HasPrefix(modelName, strings.TrimPrefix(m, "prefix:")) {
-			return true
-		}
-	}
-	return false
-}

new-api/common/page_info.go

@@ -1,82 +0,0 @@
-package common
-
-import (
-	"strconv"
-
-	"github.com/gin-gonic/gin"
-)
-
-type PageInfo struct {
-	Page     int `json:"page"`      // page num 页码
-	PageSize int `json:"page_size"` // page size 页大小
-
-	Total int `json:"total"` // 总条数，后设置
-	Items any `json:"items"` // 数据，后设置
-}
-
-func (p *PageInfo) GetStartIdx() int {
-	return (p.Page - 1) * p.PageSize
-}
-
-func (p *PageInfo) GetEndIdx() int {
-	return p.Page * p.PageSize
-}
-
-func (p *PageInfo) GetPageSize() int {
-	return p.PageSize
-}
-
-func (p *PageInfo) GetPage() int {
-	return p.Page
-}
-
-func (p *PageInfo) SetTotal(total int) {
-	p.Total = total
-}
-
-func (p *PageInfo) SetItems(items any) {
-	p.Items = items
-}
-
-func GetPageQuery(c *gin.Context) *PageInfo {
-	pageInfo := &PageInfo{}
-	// 手动获取并处理每个参数
-	if page, err := strconv.Atoi(c.Query("p")); err == nil {
-		pageInfo.Page = page
-	}
-	if pageSize, err := strconv.Atoi(c.Query("page_size")); err == nil {
-		pageInfo.PageSize = pageSize
-	}
-	if pageInfo.Page < 1 {
-		// 兼容
-		page, _ := strconv.Atoi(c.Query("p"))
-		if page != 0 {
-			pageInfo.Page = page
-		} else {
-			pageInfo.Page = 1
-		}
-	}
-
-	if pageInfo.PageSize == 0 {
-		// 兼容
-		pageSize, _ := strconv.Atoi(c.Query("ps"))
-		if pageSize != 0 {
-			pageInfo.PageSize = pageSize
-		}
-		if pageInfo.PageSize == 0 {
-			pageSize, _ = strconv.Atoi(c.Query("size")) // token page
-			if pageSize != 0 {
-				pageInfo.PageSize = pageSize
-			}
-		}
-		if pageInfo.PageSize == 0 {
-			pageInfo.PageSize = ItemsPerPage
-		}
-	}
-
-	if pageInfo.PageSize > 100 {
-		pageInfo.PageSize = 100
-	}
-
-	return pageInfo
-}

new-api/common/pprof.go

@@ -1,44 +0,0 @@
-package common
-
-import (
-	"fmt"
-	"github.com/shirou/gopsutil/cpu"
-	"os"
-	"runtime/pprof"
-	"time"
-)
-
-// Monitor 定时监控cpu使用率，超过阈值输出pprof文件
-func Monitor() {
-	for {
-		percent, err := cpu.Percent(time.Second, false)
-		if err != nil {
-			panic(err)
-		}
-		if percent[0] > 80 {
-			fmt.Println("cpu usage too high")
-			// write pprof file
-			if _, err := os.Stat("./pprof"); os.IsNotExist(err) {
-				err := os.Mkdir("./pprof", os.ModePerm)
-				if err != nil {
-					SysLog("创建pprof文件夹失败 " + err.Error())
-					continue
-				}
-			}
-			f, err := os.Create("./pprof/" + fmt.Sprintf("cpu-%s.pprof", time.Now().Format("20060102150405")))
-			if err != nil {
-				SysLog("创建pprof文件失败 " + err.Error())
-				continue
-			}
-			err = pprof.StartCPUProfile(f)
-			if err != nil {
-				SysLog("启动pprof失败 " + err.Error())
-				continue
-			}
-			time.Sleep(10 * time.Second) // profile for 30 seconds
-			pprof.StopCPUProfile()
-			f.Close()
-		}
-		time.Sleep(30 * time.Second)
-	}
-}

new-api/common/quota.go

@@ -1,5 +0,0 @@
-package common
-
-func GetTrustQuota() int {
-	return int(10 * QuotaPerUnit)
-}

new-api/common/rate-limit.go

@@ -1,70 +0,0 @@
-package common
-
-import (
-	"sync"
-	"time"
-)
-
-type InMemoryRateLimiter struct {
-	store              map[string]*[]int64
-	mutex              sync.Mutex
-	expirationDuration time.Duration
-}
-
-func (l *InMemoryRateLimiter) Init(expirationDuration time.Duration) {
-	if l.store == nil {
-		l.mutex.Lock()
-		if l.store == nil {
-			l.store = make(map[string]*[]int64)
-			l.expirationDuration = expirationDuration
-			if expirationDuration > 0 {
-				go l.clearExpiredItems()
-			}
-		}
-		l.mutex.Unlock()
-	}
-}
-
-func (l *InMemoryRateLimiter) clearExpiredItems() {
-	for {
-		time.Sleep(l.expirationDuration)
-		l.mutex.Lock()
-		now := time.Now().Unix()
-		for key := range l.store {
-			queue := l.store[key]
-			size := len(*queue)
-			if size == 0 || now-(*queue)[size-1] > int64(l.expirationDuration.Seconds()) {
-				delete(l.store, key)
-			}
-		}
-		l.mutex.Unlock()
-	}
-}
-
-// Request parameter duration's unit is seconds
-func (l *InMemoryRateLimiter) Request(key string, maxRequestNum int, duration int64) bool {
-	l.mutex.Lock()
-	defer l.mutex.Unlock()
-	// [old <-- new]
-	queue, ok := l.store[key]
-	now := time.Now().Unix()
-	if ok {
-		if len(*queue) < maxRequestNum {
-			*queue = append(*queue, now)
-			return true
-		} else {
-			if now-(*queue)[0] >= duration {
-				*queue = (*queue)[1:]
-				*queue = append(*queue, now)
-				return true
-			} else {
-				return false
-			}
-		}
-	} else {
-		s := make([]int64, 0, maxRequestNum)
-		l.store[key] = &s
-		*(l.store[key]) = append(*(l.store[key]), now)
-	}
-	return true
-}

new-api/common/redis.go

@@ -1,327 +0,0 @@
-package common
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"reflect"
-	"strconv"
-	"time"
-
-	"github.com/go-redis/redis/v8"
-	"gorm.io/gorm"
-)
-
-var RDB *redis.Client
-var RedisEnabled = true
-
-func RedisKeyCacheSeconds() int {
-	return SyncFrequency
-}
-
-// InitRedisClient This function is called after init()
-func InitRedisClient() (err error) {
-	if os.Getenv("REDIS_CONN_STRING") == "" {
-		RedisEnabled = false
-		SysLog("REDIS_CONN_STRING not set, Redis is not enabled")
-		return nil
-	}
-	if os.Getenv("SYNC_FREQUENCY") == "" {
-		SysLog("SYNC_FREQUENCY not set, use default value 60")
-		SyncFrequency = 60
-	}
-	SysLog("Redis is enabled")
-	opt, err := redis.ParseURL(os.Getenv("REDIS_CONN_STRING"))
-	if err != nil {
-		FatalLog("failed to parse Redis connection string: " + err.Error())
-	}
-	opt.PoolSize = GetEnvOrDefault("REDIS_POOL_SIZE", 10)
-	RDB = redis.NewClient(opt)
-
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-
-	_, err = RDB.Ping(ctx).Result()
-	if err != nil {
-		FatalLog("Redis ping test failed: " + err.Error())
-	}
-	if DebugEnabled {
-		SysLog(fmt.Sprintf("Redis connected to %s", opt.Addr))
-		SysLog(fmt.Sprintf("Redis database: %d", opt.DB))
-	}
-	return err
-}
-
-func ParseRedisOption() *redis.Options {
-	opt, err := redis.ParseURL(os.Getenv("REDIS_CONN_STRING"))
-	if err != nil {
-		FatalLog("failed to parse Redis connection string: " + err.Error())
-	}
-	return opt
-}
-
-func RedisSet(key string, value string, expiration time.Duration) error {
-	if DebugEnabled {
-		SysLog(fmt.Sprintf("Redis SET: key=%s, value=%s, expiration=%v", key, value, expiration))
-	}
-	ctx := context.Background()
-	return RDB.Set(ctx, key, value, expiration).Err()
-}
-
-func RedisGet(key string) (string, error) {
-	if DebugEnabled {
-		SysLog(fmt.Sprintf("Redis GET: key=%s", key))
-	}
-	ctx := context.Background()
-	val, err := RDB.Get(ctx, key).Result()
-	return val, err
-}
-
-//func RedisExpire(key string, expiration time.Duration) error {
-//	ctx := context.Background()
-//	return RDB.Expire(ctx, key, expiration).Err()
-//}
-//
-//func RedisGetEx(key string, expiration time.Duration) (string, error) {
-//	ctx := context.Background()
-//	return RDB.GetSet(ctx, key, expiration).Result()
-//}
-
-func RedisDel(key string) error {
-	if DebugEnabled {
-		SysLog(fmt.Sprintf("Redis DEL: key=%s", key))
-	}
-	ctx := context.Background()
-	return RDB.Del(ctx, key).Err()
-}
-
-func RedisDelKey(key string) error {
-	if DebugEnabled {
-		SysLog(fmt.Sprintf("Redis DEL Key: key=%s", key))
-	}
-	ctx := context.Background()
-	return RDB.Del(ctx, key).Err()
-}
-
-func RedisHSetObj(key string, obj interface{}, expiration time.Duration) error {
-	if DebugEnabled {
-		SysLog(fmt.Sprintf("Redis HSET: key=%s, obj=%+v, expiration=%v", key, obj, expiration))
-	}
-	ctx := context.Background()
-
-	data := make(map[string]interface{})
-
-	// 使用反射遍历结构体字段
-	v := reflect.ValueOf(obj).Elem()
-	t := v.Type()
-	for i := 0; i < v.NumField(); i++ {
-		field := t.Field(i)
-		value := v.Field(i)
-
-		// Skip DeletedAt field
-		if field.Type.String() == "gorm.DeletedAt" {
-			continue
-		}
-
-		// 处理指针类型
-		if value.Kind() == reflect.Ptr {
-			if value.IsNil() {
-				data[field.Name] = ""
-				continue
-			}
-			value = value.Elem()
-		}
-
-		// 处理布尔类型
-		if value.Kind() == reflect.Bool {
-			data[field.Name] = strconv.FormatBool(value.Bool())
-			continue
-		}
-
-		// 其他类型直接转换为字符串
-		data[field.Name] = fmt.Sprintf("%v", value.Interface())
-	}
-
-	txn := RDB.TxPipeline()
-	txn.HSet(ctx, key, data)
-
-	// 只有在 expiration 大于 0 时才设置过期时间
-	if expiration > 0 {
-		txn.Expire(ctx, key, expiration)
-	}
-
-	_, err := txn.Exec(ctx)
-	if err != nil {
-		return fmt.Errorf("failed to execute transaction: %w", err)
-	}
-	return nil
-}
-
-func RedisHGetObj(key string, obj interface{}) error {
-	if DebugEnabled {
-		SysLog(fmt.Sprintf("Redis HGETALL: key=%s", key))
-	}
-	ctx := context.Background()
-
-	result, err := RDB.HGetAll(ctx, key).Result()
-	if err != nil {
-		return fmt.Errorf("failed to load hash from Redis: %w", err)
-	}
-
-	if len(result) == 0 {
-		return fmt.Errorf("key %s not found in Redis", key)
-	}
-
-	// Handle both pointer and non-pointer values
-	val := reflect.ValueOf(obj)
-	if val.Kind() != reflect.Ptr {
-		return fmt.Errorf("obj must be a pointer to a struct, got %T", obj)
-	}
-
-	v := val.Elem()
-	if v.Kind() != reflect.Struct {
-		return fmt.Errorf("obj must be a pointer to a struct, got pointer to %T", v.Interface())
-	}
-
-	t := v.Type()
-	for i := 0; i < v.NumField(); i++ {
-		field := t.Field(i)
-		fieldName := field.Name
-		if value, ok := result[fieldName]; ok {
-			fieldValue := v.Field(i)
-
-			// Handle pointer types
-			if fieldValue.Kind() == reflect.Ptr {
-				if value == "" {
-					continue
-				}
-				if fieldValue.IsNil() {
-					fieldValue.Set(reflect.New(fieldValue.Type().Elem()))
-				}
-				fieldValue = fieldValue.Elem()
-			}
-
-			// Enhanced type handling for Token struct
-			switch fieldValue.Kind() {
-			case reflect.String:
-				fieldValue.SetString(value)
-			case reflect.Int, reflect.Int64:
-				intValue, err := strconv.ParseInt(value, 10, 64)
-				if err != nil {
-					return fmt.Errorf("failed to parse int field %s: %w", fieldName, err)
-				}
-				fieldValue.SetInt(intValue)
-			case reflect.Bool:
-				boolValue, err := strconv.ParseBool(value)
-				if err != nil {
-					return fmt.Errorf("failed to parse bool field %s: %w", fieldName, err)
-				}
-				fieldValue.SetBool(boolValue)
-			case reflect.Struct:
-				// Special handling for gorm.DeletedAt
-				if fieldValue.Type().String() == "gorm.DeletedAt" {
-					if value != "" {
-						timeValue, err := time.Parse(time.RFC3339, value)
-						if err != nil {
-							return fmt.Errorf("failed to parse DeletedAt field %s: %w", fieldName, err)
-						}
-						fieldValue.Set(reflect.ValueOf(gorm.DeletedAt{Time: timeValue, Valid: true}))
-					}
-				}
-			default:
-				return fmt.Errorf("unsupported field type: %s for field %s", fieldValue.Kind(), fieldName)
-			}
-		}
-	}
-
-	return nil
-}
-
-// RedisIncr Add this function to handle atomic increments
-func RedisIncr(key string, delta int64) error {
-	if DebugEnabled {
-		SysLog(fmt.Sprintf("Redis INCR: key=%s, delta=%d", key, delta))
-	}
-	// 检查键的剩余生存时间
-	ttlCmd := RDB.TTL(context.Background(), key)
-	ttl, err := ttlCmd.Result()
-	if err != nil && !errors.Is(err, redis.Nil) {
-		return fmt.Errorf("failed to get TTL: %w", err)
-	}
-
-	// 只有在 key 存在且有 TTL 时才需要特殊处理
-	if ttl > 0 {
-		ctx := context.Background()
-		// 开始一个Redis事务
-		txn := RDB.TxPipeline()
-
-		// 减少余额
-		decrCmd := txn.IncrBy(ctx, key, delta)
-		if err := decrCmd.Err(); err != nil {
-			return err // 如果减少失败，则直接返回错误
-		}
-
-		// 重新设置过期时间，使用原来的过期时间
-		txn.Expire(ctx, key, ttl)
-
-		// 执行事务
-		_, err = txn.Exec(ctx)
-		return err
-	}
-	return nil
-}
-
-func RedisHIncrBy(key, field string, delta int64) error {
-	if DebugEnabled {
-		SysLog(fmt.Sprintf("Redis HINCRBY: key=%s, field=%s, delta=%d", key, field, delta))
-	}
-	ttlCmd := RDB.TTL(context.Background(), key)
-	ttl, err := ttlCmd.Result()
-	if err != nil && !errors.Is(err, redis.Nil) {
-		return fmt.Errorf("failed to get TTL: %w", err)
-	}
-
-	if ttl > 0 {
-		ctx := context.Background()
-		txn := RDB.TxPipeline()
-
-		incrCmd := txn.HIncrBy(ctx, key, field, delta)
-		if err := incrCmd.Err(); err != nil {
-			return err
-		}
-
-		txn.Expire(ctx, key, ttl)
-
-		_, err = txn.Exec(ctx)
-		return err
-	}
-	return nil
-}
-
-func RedisHSetField(key, field string, value interface{}) error {
-	if DebugEnabled {
-		SysLog(fmt.Sprintf("Redis HSET field: key=%s, field=%s, value=%v", key, field, value))
-	}
-	ttlCmd := RDB.TTL(context.Background(), key)
-	ttl, err := ttlCmd.Result()
-	if err != nil && !errors.Is(err, redis.Nil) {
-		return fmt.Errorf("failed to get TTL: %w", err)
-	}
-
-	if ttl > 0 {
-		ctx := context.Background()
-		txn := RDB.TxPipeline()
-
-		hsetCmd := txn.HSet(ctx, key, field, value)
-		if err := hsetCmd.Err(); err != nil {
-			return err
-		}
-
-		txn.Expire(ctx, key, ttl)
-
-		_, err = txn.Exec(ctx)
-		return err
-	}
-	return nil
-}

new-api/common/ssrf_protection.go

@@ -1,327 +0,0 @@
-package common
-
-import (
-	"fmt"
-	"net"
-	"net/url"
-	"strconv"
-	"strings"
-)
-
-// SSRFProtection SSRF防护配置
-type SSRFProtection struct {
-	AllowPrivateIp         bool
-	DomainFilterMode       bool     // true: 白名单, false: 黑名单
-	DomainList             []string // domain format, e.g. example.com, *.example.com
-	IpFilterMode           bool     // true: 白名单, false: 黑名单
-	IpList                 []string // CIDR or single IP
-	AllowedPorts           []int    // 允许的端口范围
-	ApplyIPFilterForDomain bool     // 对域名启用IP过滤
-}
-
-// DefaultSSRFProtection 默认SSRF防护配置
-var DefaultSSRFProtection = &SSRFProtection{
-	AllowPrivateIp:   false,
-	DomainFilterMode: true,
-	DomainList:       []string{},
-	IpFilterMode:     true,
-	IpList:           []string{},
-	AllowedPorts:     []int{},
-}
-
-// isPrivateIP 检查IP是否为私有地址
-func isPrivateIP(ip net.IP) bool {
-	if ip.IsLoopback() || ip.IsLinkLocalUnicast() || ip.IsLinkLocalMulticast() {
-		return true
-	}
-
-	// 检查私有网段
-	private := []net.IPNet{
-		{IP: net.IPv4(10, 0, 0, 0), Mask: net.CIDRMask(8, 32)},     // 10.0.0.0/8
-		{IP: net.IPv4(172, 16, 0, 0), Mask: net.CIDRMask(12, 32)},  // 172.16.0.0/12
-		{IP: net.IPv4(192, 168, 0, 0), Mask: net.CIDRMask(16, 32)}, // 192.168.0.0/16
-		{IP: net.IPv4(127, 0, 0, 0), Mask: net.CIDRMask(8, 32)},    // 127.0.0.0/8
-		{IP: net.IPv4(169, 254, 0, 0), Mask: net.CIDRMask(16, 32)}, // 169.254.0.0/16 (链路本地)
-		{IP: net.IPv4(224, 0, 0, 0), Mask: net.CIDRMask(4, 32)},    // 224.0.0.0/4 (组播)
-		{IP: net.IPv4(240, 0, 0, 0), Mask: net.CIDRMask(4, 32)},    // 240.0.0.0/4 (保留)
-	}
-
-	for _, privateNet := range private {
-		if privateNet.Contains(ip) {
-			return true
-		}
-	}
-
-	// 检查IPv6私有地址
-	if ip.To4() == nil {
-		// IPv6 loopback
-		if ip.Equal(net.IPv6loopback) {
-			return true
-		}
-		// IPv6 link-local
-		if strings.HasPrefix(ip.String(), "fe80:") {
-			return true
-		}
-		// IPv6 unique local
-		if strings.HasPrefix(ip.String(), "fc") || strings.HasPrefix(ip.String(), "fd") {
-			return true
-		}
-	}
-
-	return false
-}
-
-// parsePortRanges 解析端口范围配置
-// 支持格式: "80", "443", "8000-9000"
-func parsePortRanges(portConfigs []string) ([]int, error) {
-	var ports []int
-
-	for _, config := range portConfigs {
-		config = strings.TrimSpace(config)
-		if config == "" {
-			continue
-		}
-
-		if strings.Contains(config, "-") {
-			// 处理端口范围 "8000-9000"
-			parts := strings.Split(config, "-")
-			if len(parts) != 2 {
-				return nil, fmt.Errorf("invalid port range format: %s", config)
-			}
-
-			startPort, err := strconv.Atoi(strings.TrimSpace(parts[0]))
-			if err != nil {
-				return nil, fmt.Errorf("invalid start port in range %s: %v", config, err)
-			}
-
-			endPort, err := strconv.Atoi(strings.TrimSpace(parts[1]))
-			if err != nil {
-				return nil, fmt.Errorf("invalid end port in range %s: %v", config, err)
-			}
-
-			if startPort > endPort {
-				return nil, fmt.Errorf("invalid port range %s: start port cannot be greater than end port", config)
-			}
-
-			if startPort < 1 || startPort > 65535 || endPort < 1 || endPort > 65535 {
-				return nil, fmt.Errorf("port range %s contains invalid port numbers (must be 1-65535)", config)
-			}
-
-			// 添加范围内的所有端口
-			for port := startPort; port <= endPort; port++ {
-				ports = append(ports, port)
-			}
-		} else {
-			// 处理单个端口 "80"
-			port, err := strconv.Atoi(config)
-			if err != nil {
-				return nil, fmt.Errorf("invalid port number: %s", config)
-			}
-
-			if port < 1 || port > 65535 {
-				return nil, fmt.Errorf("invalid port number %d (must be 1-65535)", port)
-			}
-
-			ports = append(ports, port)
-		}
-	}
-
-	return ports, nil
-}
-
-// isAllowedPort 检查端口是否被允许
-func (p *SSRFProtection) isAllowedPort(port int) bool {
-	if len(p.AllowedPorts) == 0 {
-		return true // 如果没有配置端口限制，则允许所有端口
-	}
-
-	for _, allowedPort := range p.AllowedPorts {
-		if port == allowedPort {
-			return true
-		}
-	}
-	return false
-}
-
-// isDomainWhitelisted 检查域名是否在白名单中
-func isDomainListed(domain string, list []string) bool {
-	if len(list) == 0 {
-		return false
-	}
-
-	domain = strings.ToLower(domain)
-	for _, item := range list {
-		item = strings.ToLower(strings.TrimSpace(item))
-		if item == "" {
-			continue
-		}
-		// 精确匹配
-		if domain == item {
-			return true
-		}
-		// 通配符匹配 (*.example.com)
-		if strings.HasPrefix(item, "*.") {
-			suffix := strings.TrimPrefix(item, "*.")
-			if strings.HasSuffix(domain, "."+suffix) || domain == suffix {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-func (p *SSRFProtection) isDomainAllowed(domain string) bool {
-	listed := isDomainListed(domain, p.DomainList)
-	if p.DomainFilterMode { // 白名单
-		return listed
-	}
-	// 黑名单
-	return !listed
-}
-
-// isIPWhitelisted 检查IP是否在白名单中
-
-func isIPListed(ip net.IP, list []string) bool {
-	if len(list) == 0 {
-		return false
-	}
-
-	for _, whitelistCIDR := range list {
-		_, network, err := net.ParseCIDR(whitelistCIDR)
-		if err != nil {
-			// 尝试作为单个IP处理
-			if whitelistIP := net.ParseIP(whitelistCIDR); whitelistIP != nil {
-				if ip.Equal(whitelistIP) {
-					return true
-				}
-			}
-			continue
-		}
-
-		if network.Contains(ip) {
-			return true
-		}
-	}
-	return false
-}
-
-// IsIPAccessAllowed 检查IP是否允许访问
-func (p *SSRFProtection) IsIPAccessAllowed(ip net.IP) bool {
-	// 私有IP限制
-	if isPrivateIP(ip) && !p.AllowPrivateIp {
-		return false
-	}
-
-	listed := isIPListed(ip, p.IpList)
-	if p.IpFilterMode { // 白名单
-		return listed
-	}
-	// 黑名单
-	return !listed
-}
-
-// ValidateURL 验证URL是否安全
-func (p *SSRFProtection) ValidateURL(urlStr string) error {
-	// 解析URL
-	u, err := url.Parse(urlStr)
-	if err != nil {
-		return fmt.Errorf("invalid URL format: %v", err)
-	}
-
-	// 只允许HTTP/HTTPS协议
-	if u.Scheme != "http" && u.Scheme != "https" {
-		return fmt.Errorf("unsupported protocol: %s (only http/https allowed)", u.Scheme)
-	}
-
-	// 解析主机和端口
-	host, portStr, err := net.SplitHostPort(u.Host)
-	if err != nil {
-		// 没有端口，使用默认端口
-		host = u.Hostname()
-		if u.Scheme == "https" {
-			portStr = "443"
-		} else {
-			portStr = "80"
-		}
-	}
-
-	// 验证端口
-	port, err := strconv.Atoi(portStr)
-	if err != nil {
-		return fmt.Errorf("invalid port: %s", portStr)
-	}
-
-	if !p.isAllowedPort(port) {
-		return fmt.Errorf("port %d is not allowed", port)
-	}
-
-	// 如果 host 是 IP，则跳过域名检查
-	if ip := net.ParseIP(host); ip != nil {
-		if !p.IsIPAccessAllowed(ip) {
-			if isPrivateIP(ip) {
-				return fmt.Errorf("private IP address not allowed: %s", ip.String())
-			}
-			if p.IpFilterMode {
-				return fmt.Errorf("ip not in whitelist: %s", ip.String())
-			}
-			return fmt.Errorf("ip in blacklist: %s", ip.String())
-		}
-		return nil
-	}
-
-	// 先进行域名过滤
-	if !p.isDomainAllowed(host) {
-		if p.DomainFilterMode {
-			return fmt.Errorf("domain not in whitelist: %s", host)
-		}
-		return fmt.Errorf("domain in blacklist: %s", host)
-	}
-
-	// 若未启用对域名应用IP过滤，则到此通过
-	if !p.ApplyIPFilterForDomain {
-		return nil
-	}
-
-	// 解析域名对应IP并检查
-	ips, err := net.LookupIP(host)
-	if err != nil {
-		return fmt.Errorf("DNS resolution failed for %s: %v", host, err)
-	}
-	for _, ip := range ips {
-		if !p.IsIPAccessAllowed(ip) {
-			if isPrivateIP(ip) && !p.AllowPrivateIp {
-				return fmt.Errorf("private IP address not allowed: %s resolves to %s", host, ip.String())
-			}
-			if p.IpFilterMode {
-				return fmt.Errorf("ip not in whitelist: %s resolves to %s", host, ip.String())
-			}
-			return fmt.Errorf("ip in blacklist: %s resolves to %s", host, ip.String())
-		}
-	}
-	return nil
-}
-
-// ValidateURLWithFetchSetting 使用FetchSetting配置验证URL
-func ValidateURLWithFetchSetting(urlStr string, enableSSRFProtection, allowPrivateIp bool, domainFilterMode bool, ipFilterMode bool, domainList, ipList, allowedPorts []string, applyIPFilterForDomain bool) error {
-	// 如果SSRF防护被禁用，直接返回成功
-	if !enableSSRFProtection {
-		return nil
-	}
-
-	// 解析端口范围配置
-	allowedPortInts, err := parsePortRanges(allowedPorts)
-	if err != nil {
-		return fmt.Errorf("request reject - invalid port configuration: %v", err)
-	}
-
-	protection := &SSRFProtection{
-		AllowPrivateIp:         allowPrivateIp,
-		DomainFilterMode:       domainFilterMode,
-		DomainList:             domainList,
-		IpFilterMode:           ipFilterMode,
-		IpList:                 ipList,
-		AllowedPorts:           allowedPortInts,
-		ApplyIPFilterForDomain: applyIPFilterForDomain,
-	}
-	return protection.ValidateURL(urlStr)
-}

new-api/common/str.go

@@ -1,237 +0,0 @@
-package common
-
-import (
-	"encoding/base64"
-	"encoding/json"
-	"math/rand"
-	"net/url"
-	"regexp"
-	"strconv"
-	"strings"
-	"unsafe"
-)
-
-func GetStringIfEmpty(str string, defaultValue string) string {
-	if str == "" {
-		return defaultValue
-	}
-	return str
-}
-
-func GetRandomString(length int) string {
-	//rand.Seed(time.Now().UnixNano())
-	key := make([]byte, length)
-	for i := 0; i < length; i++ {
-		key[i] = keyChars[rand.Intn(len(keyChars))]
-	}
-	return string(key)
-}
-
-func MapToJsonStr(m map[string]interface{}) string {
-	bytes, err := json.Marshal(m)
-	if err != nil {
-		return ""
-	}
-	return string(bytes)
-}
-
-func StrToMap(str string) (map[string]interface{}, error) {
-	m := make(map[string]interface{})
-	err := Unmarshal([]byte(str), &m)
-	if err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func StrToJsonArray(str string) ([]interface{}, error) {
-	var js []interface{}
-	err := json.Unmarshal([]byte(str), &js)
-	if err != nil {
-		return nil, err
-	}
-	return js, nil
-}
-
-func IsJsonArray(str string) bool {
-	var js []interface{}
-	return json.Unmarshal([]byte(str), &js) == nil
-}
-
-func IsJsonObject(str string) bool {
-	var js map[string]interface{}
-	return json.Unmarshal([]byte(str), &js) == nil
-}
-
-func String2Int(str string) int {
-	num, err := strconv.Atoi(str)
-	if err != nil {
-		return 0
-	}
-	return num
-}
-
-func StringsContains(strs []string, str string) bool {
-	for _, s := range strs {
-		if s == str {
-			return true
-		}
-	}
-	return false
-}
-
-// StringToByteSlice []byte only read, panic on append
-func StringToByteSlice(s string) []byte {
-	tmp1 := (*[2]uintptr)(unsafe.Pointer(&s))
-	tmp2 := [3]uintptr{tmp1[0], tmp1[1], tmp1[1]}
-	return *(*[]byte)(unsafe.Pointer(&tmp2))
-}
-
-func EncodeBase64(str string) string {
-	return base64.StdEncoding.EncodeToString([]byte(str))
-}
-
-func GetJsonString(data any) string {
-	if data == nil {
-		return ""
-	}
-	b, _ := json.Marshal(data)
-	return string(b)
-}
-
-// MaskEmail masks a user email to prevent PII leakage in logs
-// Returns "***masked***" if email is empty, otherwise shows only the domain part
-func MaskEmail(email string) string {
-	if email == "" {
-		return "***masked***"
-	}
-
-	// Find the @ symbol
-	atIndex := strings.Index(email, "@")
-	if atIndex == -1 {
-		// No @ symbol found, return masked
-		return "***masked***"
-	}
-
-	// Return only the domain part with @ symbol
-	return "***@" + email[atIndex+1:]
-}
-
-// maskHostTail returns the tail parts of a domain/host that should be preserved.
-// It keeps 2 parts for likely country-code TLDs (e.g., co.uk, com.cn), otherwise keeps only the TLD.
-func maskHostTail(parts []string) []string {
-	if len(parts) < 2 {
-		return parts
-	}
-	lastPart := parts[len(parts)-1]
-	secondLastPart := parts[len(parts)-2]
-	if len(lastPart) == 2 && len(secondLastPart) <= 3 {
-		// Likely country code TLD like co.uk, com.cn
-		return []string{secondLastPart, lastPart}
-	}
-	return []string{lastPart}
-}
-
-// maskHostForURL collapses subdomains and keeps only masked prefix + preserved tail.
-// Example: api.openai.com -> ***.com, sub.domain.co.uk -> ***.co.uk
-func maskHostForURL(host string) string {
-	parts := strings.Split(host, ".")
-	if len(parts) < 2 {
-		return "***"
-	}
-	tail := maskHostTail(parts)
-	return "***." + strings.Join(tail, ".")
-}
-
-// maskHostForPlainDomain masks a plain domain and reflects subdomain depth with multiple ***.
-// Example: openai.com -> ***.com, api.openai.com -> ***.***.com, sub.domain.co.uk -> ***.***.co.uk
-func maskHostForPlainDomain(domain string) string {
-	parts := strings.Split(domain, ".")
-	if len(parts) < 2 {
-		return domain
-	}
-	tail := maskHostTail(parts)
-	numStars := len(parts) - len(tail)
-	if numStars < 1 {
-		numStars = 1
-	}
-	stars := strings.TrimSuffix(strings.Repeat("***.", numStars), ".")
-	return stars + "." + strings.Join(tail, ".")
-}
-
-// MaskSensitiveInfo masks sensitive information like URLs, IPs, and domain names in a string
-// Example:
-// http://example.com -> http://***.com
-// https://api.test.org/v1/users/123?key=secret -> https://***.org/***/***/?key=***
-// https://sub.domain.co.uk/path/to/resource -> https://***.co.uk/***/***
-// 192.168.1.1 -> ***.***.***.***
-// openai.com -> ***.com
-// www.openai.com -> ***.***.com
-// api.openai.com -> ***.***.com
-func MaskSensitiveInfo(str string) string {
-	// Mask URLs
-	urlPattern := regexp.MustCompile(`(http|https)://[^\s/$.?#].[^\s]*`)
-	str = urlPattern.ReplaceAllStringFunc(str, func(urlStr string) string {
-		u, err := url.Parse(urlStr)
-		if err != nil {
-			return urlStr
-		}
-
-		host := u.Host
-		if host == "" {
-			return urlStr
-		}
-
-		// Mask host with unified logic
-		maskedHost := maskHostForURL(host)
-
-		result := u.Scheme + "://" + maskedHost
-
-		// Mask path
-		if u.Path != "" && u.Path != "/" {
-			pathParts := strings.Split(strings.Trim(u.Path, "/"), "/")
-			maskedPathParts := make([]string, len(pathParts))
-			for i := range pathParts {
-				if pathParts[i] != "" {
-					maskedPathParts[i] = "***"
-				}
-			}
-			if len(maskedPathParts) > 0 {
-				result += "/" + strings.Join(maskedPathParts, "/")
-			}
-		} else if u.Path == "/" {
-			result += "/"
-		}
-
-		// Mask query parameters
-		if u.RawQuery != "" {
-			values, err := url.ParseQuery(u.RawQuery)
-			if err != nil {
-				// If can't parse query, just mask the whole query string
-				result += "?***"
-			} else {
-				maskedParams := make([]string, 0, len(values))
-				for key := range values {
-					maskedParams = append(maskedParams, key+"=***")
-				}
-				if len(maskedParams) > 0 {
-					result += "?" + strings.Join(maskedParams, "&")
-				}
-			}
-		}
-
-		return result
-	})
-
-	// Mask domain names without protocol (like openai.com, www.openai.com)
-	domainPattern := regexp.MustCompile(`\b(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}\b`)
-	str = domainPattern.ReplaceAllStringFunc(str, func(domain string) string {
-		return maskHostForPlainDomain(domain)
-	})
-
-	// Mask IP addresses
-	ipPattern := regexp.MustCompile(`\b(?:\d{1,3}\.){3}\d{1,3}\b`)
-	str = ipPattern.ReplaceAllString(str, "***.***.***.***")
-
-	return str
-}

new-api/common/sys_log.go

@@ -1,55 +0,0 @@
-package common
-
-import (
-	"fmt"
-	"os"
-	"time"
-
-	"github.com/gin-gonic/gin"
-)
-
-func SysLog(s string) {
-	t := time.Now()
-	_, _ = fmt.Fprintf(gin.DefaultWriter, "[SYS] %v | %s \n", t.Format("2006/01/02 - 15:04:05"), s)
-}
-
-func SysError(s string) {
-	t := time.Now()
-	_, _ = fmt.Fprintf(gin.DefaultErrorWriter, "[SYS] %v | %s \n", t.Format("2006/01/02 - 15:04:05"), s)
-}
-
-func FatalLog(v ...any) {
-	t := time.Now()
-	_, _ = fmt.Fprintf(gin.DefaultErrorWriter, "[FATAL] %v | %v \n", t.Format("2006/01/02 - 15:04:05"), v)
-	os.Exit(1)
-}
-
-func LogStartupSuccess(startTime time.Time, port string) {
-
-	duration := time.Since(startTime)
-	durationMs := duration.Milliseconds()
-
-	// Get network IPs
-	networkIps := GetNetworkIps()
-
-	// Print blank line for spacing
-	fmt.Fprintf(gin.DefaultWriter, "\n")
-
-	// Print the main success message
-	fmt.Fprintf(gin.DefaultWriter, "  \033[32m%s %s\033[0m  ready in %d ms\n", SystemName, Version, durationMs)
-	fmt.Fprintf(gin.DefaultWriter, "\n")
-
-	// Skip fancy startup message in container environments
-	if !IsRunningInContainer() {
-		// Print local URL
-		fmt.Fprintf(gin.DefaultWriter, "  ➜  \033[1mLocal:\033[0m   http://localhost:%s/\n", port)
-	}
-
-	// Print network URLs
-	for _, ip := range networkIps {
-		fmt.Fprintf(gin.DefaultWriter, "  ➜  \033[1mNetwork:\033[0m http://%s:%s/\n", ip, port)
-	}
-
-	// Print blank line for spacing
-	fmt.Fprintf(gin.DefaultWriter, "\n")
-}

new-api/common/topup-ratio.go

@@ -1,33 +0,0 @@
-package common
-
-import (
-	"encoding/json"
-)
-
-var TopupGroupRatio = map[string]float64{
-	"default": 1,
-	"vip":     1,
-	"svip":    1,
-}
-
-func TopupGroupRatio2JSONString() string {
-	jsonBytes, err := json.Marshal(TopupGroupRatio)
-	if err != nil {
-		SysError("error marshalling model ratio: " + err.Error())
-	}
-	return string(jsonBytes)
-}
-
-func UpdateTopupGroupRatioByJSONString(jsonStr string) error {
-	TopupGroupRatio = make(map[string]float64)
-	return json.Unmarshal([]byte(jsonStr), &TopupGroupRatio)
-}
-
-func GetTopupGroupRatio(name string) float64 {
-	ratio, ok := TopupGroupRatio[name]
-	if !ok {
-		SysError("topup group ratio not found: " + name)
-		return 1
-	}
-	return ratio
-}

new-api/common/totp.go

@@ -1,150 +0,0 @@
-package common
-
-import (
-	"crypto/rand"
-	"fmt"
-	"os"
-	"strconv"
-	"strings"
-
-	"github.com/pquerna/otp"
-	"github.com/pquerna/otp/totp"
-)
-
-const (
-	// 备用码配置
-	BackupCodeLength = 8 // 备用码长度
-	BackupCodeCount  = 4 // 生成备用码数量
-
-	// 限制配置
-	MaxFailAttempts = 5   // 最大失败尝试次数
-	LockoutDuration = 300 // 锁定时间（秒）
-)
-
-// GenerateTOTPSecret 生成TOTP密钥和配置
-func GenerateTOTPSecret(accountName string) (*otp.Key, error) {
-	issuer := Get2FAIssuer()
-	return totp.Generate(totp.GenerateOpts{
-		Issuer:      issuer,
-		AccountName: accountName,
-		Period:      30,
-		Digits:      otp.DigitsSix,
-		Algorithm:   otp.AlgorithmSHA1,
-	})
-}
-
-// ValidateTOTPCode 验证TOTP验证码
-func ValidateTOTPCode(secret, code string) bool {
-	// 清理验证码格式
-	cleanCode := strings.ReplaceAll(code, " ", "")
-	if len(cleanCode) != 6 {
-		return false
-	}
-
-	// 验证验证码
-	return totp.Validate(cleanCode, secret)
-}
-
-// GenerateBackupCodes 生成备用恢复码
-func GenerateBackupCodes() ([]string, error) {
-	codes := make([]string, BackupCodeCount)
-
-	for i := 0; i < BackupCodeCount; i++ {
-		code, err := generateRandomBackupCode()
-		if err != nil {
-			return nil, err
-		}
-		codes[i] = code
-	}
-
-	return codes, nil
-}
-
-// generateRandomBackupCode 生成单个备用码
-func generateRandomBackupCode() (string, error) {
-	const charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
-	code := make([]byte, BackupCodeLength)
-
-	for i := range code {
-		randomBytes := make([]byte, 1)
-		_, err := rand.Read(randomBytes)
-		if err != nil {
-			return "", err
-		}
-		code[i] = charset[int(randomBytes[0])%len(charset)]
-	}
-
-	// 格式化为 XXXX-XXXX 格式
-	return fmt.Sprintf("%s-%s", string(code[:4]), string(code[4:])), nil
-}
-
-// ValidateBackupCode 验证备用码格式
-func ValidateBackupCode(code string) bool {
-	// 移除所有分隔符并转为大写
-	cleanCode := strings.ToUpper(strings.ReplaceAll(code, "-", ""))
-	if len(cleanCode) != BackupCodeLength {
-		return false
-	}
-
-	// 检查字符是否合法
-	for _, char := range cleanCode {
-		if !((char >= 'A' && char <= 'Z') || (char >= '0' && char <= '9')) {
-			return false
-		}
-	}
-
-	return true
-}
-
-// NormalizeBackupCode 标准化备用码格式
-func NormalizeBackupCode(code string) string {
-	cleanCode := strings.ToUpper(strings.ReplaceAll(code, "-", ""))
-	if len(cleanCode) == BackupCodeLength {
-		return fmt.Sprintf("%s-%s", cleanCode[:4], cleanCode[4:])
-	}
-	return code
-}
-
-// HashBackupCode 对备用码进行哈希
-func HashBackupCode(code string) (string, error) {
-	normalizedCode := NormalizeBackupCode(code)
-	return Password2Hash(normalizedCode)
-}
-
-// Get2FAIssuer 获取2FA发行者名称
-func Get2FAIssuer() string {
-	return SystemName
-}
-
-// getEnvOrDefault 获取环境变量或默认值
-func getEnvOrDefault(key, defaultValue string) string {
-	if value, exists := os.LookupEnv(key); exists {
-		return value
-	}
-	return defaultValue
-}
-
-// ValidateNumericCode 验证数字验证码格式
-func ValidateNumericCode(code string) (string, error) {
-	// 移除空格
-	code = strings.ReplaceAll(code, " ", "")
-
-	if len(code) != 6 {
-		return "", fmt.Errorf("验证码必须是6位数字")
-	}
-
-	// 检查是否为纯数字
-	if _, err := strconv.Atoi(code); err != nil {
-		return "", fmt.Errorf("验证码只能包含数字")
-	}
-
-	return code, nil
-}
-
-// GenerateQRCodeData 生成二维码数据
-func GenerateQRCodeData(secret, username string) string {
-	issuer := Get2FAIssuer()
-	accountName := fmt.Sprintf("%s (%s)", username, issuer)
-	return fmt.Sprintf("otpauth://totp/%s:%s?secret=%s&issuer=%s&digits=6&period=30",
-		issuer, accountName, secret, issuer)
-}

new-api/common/utils.go

@@ -1,384 +0,0 @@
-package common
-
-import (
-	"bytes"
-	"context"
-	crand "crypto/rand"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"html/template"
-	"io"
-	"log"
-	"math/big"
-	"math/rand"
-	"net"
-	"net/url"
-	"os"
-	"os/exec"
-	"runtime"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/pkg/errors"
-)
-
-func OpenBrowser(url string) {
-	var err error
-
-	switch runtime.GOOS {
-	case "linux":
-		err = exec.Command("xdg-open", url).Start()
-	case "windows":
-		err = exec.Command("rundll32", "url.dll,FileProtocolHandler", url).Start()
-	case "darwin":
-		err = exec.Command("open", url).Start()
-	}
-	if err != nil {
-		log.Println(err)
-	}
-}
-
-func GetIp() (ip string) {
-	ips, err := net.InterfaceAddrs()
-	if err != nil {
-		log.Println(err)
-		return ip
-	}
-
-	for _, a := range ips {
-		if ipNet, ok := a.(*net.IPNet); ok && !ipNet.IP.IsLoopback() {
-			if ipNet.IP.To4() != nil {
-				ip = ipNet.IP.String()
-				if strings.HasPrefix(ip, "10") {
-					return
-				}
-				if strings.HasPrefix(ip, "172") {
-					return
-				}
-				if strings.HasPrefix(ip, "192.168") {
-					return
-				}
-				ip = ""
-			}
-		}
-	}
-	return
-}
-
-func GetNetworkIps() []string {
-	var networkIps []string
-	ips, err := net.InterfaceAddrs()
-	if err != nil {
-		log.Println(err)
-		return networkIps
-	}
-
-	for _, a := range ips {
-		if ipNet, ok := a.(*net.IPNet); ok && !ipNet.IP.IsLoopback() {
-			if ipNet.IP.To4() != nil {
-				ip := ipNet.IP.String()
-				// Include common private network ranges
-				if strings.HasPrefix(ip, "10.") ||
-					strings.HasPrefix(ip, "172.") ||
-					strings.HasPrefix(ip, "192.168.") {
-					networkIps = append(networkIps, ip)
-				}
-			}
-		}
-	}
-	return networkIps
-}
-
-// IsRunningInContainer detects if the application is running inside a container
-func IsRunningInContainer() bool {
-	// Method 1: Check for .dockerenv file (Docker containers)
-	if _, err := os.Stat("/.dockerenv"); err == nil {
-		return true
-	}
-
-	// Method 2: Check cgroup for container indicators
-	if data, err := os.ReadFile("/proc/1/cgroup"); err == nil {
-		content := string(data)
-		if strings.Contains(content, "docker") ||
-			strings.Contains(content, "containerd") ||
-			strings.Contains(content, "kubepods") ||
-			strings.Contains(content, "/lxc/") {
-			return true
-		}
-	}
-
-	// Method 3: Check environment variables commonly set by container runtimes
-	containerEnvVars := []string{
-		"KUBERNETES_SERVICE_HOST",
-		"DOCKER_CONTAINER",
-		"container",
-	}
-
-	for _, envVar := range containerEnvVars {
-		if os.Getenv(envVar) != "" {
-			return true
-		}
-	}
-
-	// Method 4: Check if init process is not the traditional init
-	if data, err := os.ReadFile("/proc/1/comm"); err == nil {
-		comm := strings.TrimSpace(string(data))
-		// In containers, process 1 is often not "init" or "systemd"
-		if comm != "init" && comm != "systemd" {
-			// Additional check: if it's a common container entrypoint
-			if strings.Contains(comm, "docker") ||
-				strings.Contains(comm, "containerd") ||
-				strings.Contains(comm, "runc") {
-				return true
-			}
-		}
-	}
-
-	return false
-}
-
-var sizeKB = 1024
-var sizeMB = sizeKB * 1024
-var sizeGB = sizeMB * 1024
-
-func Bytes2Size(num int64) string {
-	numStr := ""
-	unit := "B"
-	if num/int64(sizeGB) > 1 {
-		numStr = fmt.Sprintf("%.2f", float64(num)/float64(sizeGB))
-		unit = "GB"
-	} else if num/int64(sizeMB) > 1 {
-		numStr = fmt.Sprintf("%d", int(float64(num)/float64(sizeMB)))
-		unit = "MB"
-	} else if num/int64(sizeKB) > 1 {
-		numStr = fmt.Sprintf("%d", int(float64(num)/float64(sizeKB)))
-		unit = "KB"
-	} else {
-		numStr = fmt.Sprintf("%d", num)
-	}
-	return numStr + " " + unit
-}
-
-func Seconds2Time(num int) (time string) {
-	if num/31104000 > 0 {
-		time += strconv.Itoa(num/31104000) + " 年 "
-		num %= 31104000
-	}
-	if num/2592000 > 0 {
-		time += strconv.Itoa(num/2592000) + " 个月 "
-		num %= 2592000
-	}
-	if num/86400 > 0 {
-		time += strconv.Itoa(num/86400) + " 天 "
-		num %= 86400
-	}
-	if num/3600 > 0 {
-		time += strconv.Itoa(num/3600) + " 小时 "
-		num %= 3600
-	}
-	if num/60 > 0 {
-		time += strconv.Itoa(num/60) + " 分钟 "
-		num %= 60
-	}
-	time += strconv.Itoa(num) + " 秒"
-	return
-}
-
-func Interface2String(inter interface{}) string {
-	switch inter.(type) {
-	case string:
-		return inter.(string)
-	case int:
-		return fmt.Sprintf("%d", inter.(int))
-	case float64:
-		return fmt.Sprintf("%f", inter.(float64))
-	case bool:
-		if inter.(bool) {
-			return "true"
-		} else {
-			return "false"
-		}
-	case nil:
-		return ""
-	}
-	return fmt.Sprintf("%v", inter)
-}
-
-func UnescapeHTML(x string) interface{} {
-	return template.HTML(x)
-}
-
-func IntMax(a int, b int) int {
-	if a >= b {
-		return a
-	} else {
-		return b
-	}
-}
-
-func IsIP(s string) bool {
-	ip := net.ParseIP(s)
-	return ip != nil
-}
-
-func GetUUID() string {
-	code := uuid.New().String()
-	code = strings.Replace(code, "-", "", -1)
-	return code
-}
-
-const keyChars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-
-func init() {
-	rand.New(rand.NewSource(time.Now().UnixNano()))
-}
-
-func GenerateRandomCharsKey(length int) (string, error) {
-	b := make([]byte, length)
-	maxI := big.NewInt(int64(len(keyChars)))
-
-	for i := range b {
-		n, err := crand.Int(crand.Reader, maxI)
-		if err != nil {
-			return "", err
-		}
-		b[i] = keyChars[n.Int64()]
-	}
-
-	return string(b), nil
-}
-
-func GenerateRandomKey(length int) (string, error) {
-	bytes := make([]byte, length*3/4) // 对于48位的输出，这里应该是36
-	if _, err := crand.Read(bytes); err != nil {
-		return "", err
-	}
-	return base64.StdEncoding.EncodeToString(bytes), nil
-}
-
-func GenerateKey() (string, error) {
-	//rand.Seed(time.Now().UnixNano())
-	return GenerateRandomCharsKey(48)
-}
-
-func GetRandomInt(max int) int {
-	//rand.Seed(time.Now().UnixNano())
-	return rand.Intn(max)
-}
-
-func GetTimestamp() int64 {
-	return time.Now().Unix()
-}
-
-func GetTimeString() string {
-	now := time.Now()
-	return fmt.Sprintf("%s%d", now.Format("20060102150405"), now.UnixNano()%1e9)
-}
-
-func Max(a int, b int) int {
-	if a >= b {
-		return a
-	} else {
-		return b
-	}
-}
-
-func MessageWithRequestId(message string, id string) string {
-	return fmt.Sprintf("%s (request id: %s)", message, id)
-}
-
-func RandomSleep() {
-	// Sleep for 0-3000 ms
-	time.Sleep(time.Duration(rand.Intn(3000)) * time.Millisecond)
-}
-
-func GetPointer[T any](v T) *T {
-	return &v
-}
-
-func Any2Type[T any](data any) (T, error) {
-	var zero T
-	bytes, err := json.Marshal(data)
-	if err != nil {
-		return zero, err
-	}
-	var res T
-	err = json.Unmarshal(bytes, &res)
-	if err != nil {
-		return zero, err
-	}
-	return res, nil
-}
-
-// SaveTmpFile saves data to a temporary file. The filename would be apppended with a random string.
-func SaveTmpFile(filename string, data io.Reader) (string, error) {
-	f, err := os.CreateTemp(os.TempDir(), filename)
-	if err != nil {
-		return "", errors.Wrapf(err, "failed to create temporary file %s", filename)
-	}
-	defer f.Close()
-
-	_, err = io.Copy(f, data)
-	if err != nil {
-		return "", errors.Wrapf(err, "failed to copy data to temporary file %s", filename)
-	}
-
-	return f.Name(), nil
-}
-
-// GetAudioDuration returns the duration of an audio file in seconds.
-func GetAudioDuration(ctx context.Context, filename string, ext string) (float64, error) {
-	// ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 {{input}}
-	c := exec.CommandContext(ctx, "ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", filename)
-	output, err := c.Output()
-	if err != nil {
-		return 0, errors.Wrap(err, "failed to get audio duration")
-	}
-	durationStr := string(bytes.TrimSpace(output))
-	if durationStr == "N/A" {
-		// Create a temporary output file name
-		tmpFp, err := os.CreateTemp("", "audio-*"+ext)
-		if err != nil {
-			return 0, errors.Wrap(err, "failed to create temporary file")
-		}
-		tmpName := tmpFp.Name()
-		// Close immediately so ffmpeg can open the file on Windows.
-		_ = tmpFp.Close()
-		defer os.Remove(tmpName)
-
-		// ffmpeg -y -i filename -vcodec copy -acodec copy <tmpName>
-		ffmpegCmd := exec.CommandContext(ctx, "ffmpeg", "-y", "-i", filename, "-vcodec", "copy", "-acodec", "copy", tmpName)
-		if err := ffmpegCmd.Run(); err != nil {
-			return 0, errors.Wrap(err, "failed to run ffmpeg")
-		}
-
-		// Recalculate the duration of the new file
-		c = exec.CommandContext(ctx, "ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", tmpName)
-		output, err := c.Output()
-		if err != nil {
-			return 0, errors.Wrap(err, "failed to get audio duration after ffmpeg")
-		}
-		durationStr = string(bytes.TrimSpace(output))
-	}
-	return strconv.ParseFloat(durationStr, 64)
-}
-
-// BuildURL concatenates base and endpoint, returns the complete url string
-func BuildURL(base string, endpoint string) string {
-	u, err := url.Parse(base)
-	if err != nil {
-		return base + endpoint
-	}
-	end := endpoint
-	if end == "" {
-		end = "/"
-	}
-	ref, err := url.Parse(end)
-	if err != nil {
-		return base + endpoint
-	}
-	return u.ResolveReference(ref).String()
-}

new-api/common/validate.go

@@ -1,9 +0,0 @@
-package common
-
-import "github.com/go-playground/validator/v10"
-
-var Validate *validator.Validate
-
-func init() {
-	Validate = validator.New()
-}

new-api/common/verification.go

@@ -1,77 +0,0 @@
-package common
-
-import (
-	"github.com/google/uuid"
-	"strings"
-	"sync"
-	"time"
-)
-
-type verificationValue struct {
-	code string
-	time time.Time
-}
-
-const (
-	EmailVerificationPurpose = "v"
-	PasswordResetPurpose     = "r"
-)
-
-var verificationMutex sync.Mutex
-var verificationMap map[string]verificationValue
-var verificationMapMaxSize = 10
-var VerificationValidMinutes = 10
-
-func GenerateVerificationCode(length int) string {
-	code := uuid.New().String()
-	code = strings.Replace(code, "-", "", -1)
-	if length == 0 {
-		return code
-	}
-	return code[:length]
-}
-
-func RegisterVerificationCodeWithKey(key string, code string, purpose string) {
-	verificationMutex.Lock()
-	defer verificationMutex.Unlock()
-	verificationMap[purpose+key] = verificationValue{
-		code: code,
-		time: time.Now(),
-	}
-	if len(verificationMap) > verificationMapMaxSize {
-		removeExpiredPairs()
-	}
-}
-
-func VerifyCodeWithKey(key string, code string, purpose string) bool {
-	verificationMutex.Lock()
-	defer verificationMutex.Unlock()
-	value, okay := verificationMap[purpose+key]
-	now := time.Now()
-	if !okay || int(now.Sub(value.time).Seconds()) >= VerificationValidMinutes*60 {
-		return false
-	}
-	return code == value.code
-}
-
-func DeleteKey(key string, purpose string) {
-	verificationMutex.Lock()
-	defer verificationMutex.Unlock()
-	delete(verificationMap, purpose+key)
-}
-
-// no lock inside, so the caller must lock the verificationMap before calling!
-func removeExpiredPairs() {
-	now := time.Now()
-	for key := range verificationMap {
-		if int(now.Sub(verificationMap[key].time).Seconds()) >= VerificationValidMinutes*60 {
-			delete(verificationMap, key)
-		}
-	}
-}
-
-func init() {
-	verificationMutex.Lock()
-	defer verificationMutex.Unlock()
-	verificationMap = make(map[string]verificationValue)
-}

new-api/constant/README.md

@@ -1,26 +0,0 @@
-# constant 包 (`/constant`)
-
-该目录仅用于放置全局可复用的**常量定义**，不包含任何业务逻辑或依赖关系。
-
-## 当前文件
-
-| 文件                   | 说明                                                                  |
-|----------------------|---------------------------------------------------------------------|
-| `azure.go`           | 定义与 Azure 相关的全局常量，如 `AzureNoRemoveDotTime`（控制删除 `.` 的截止时间）。         |
-| `cache_key.go`       | 缓存键格式字符串及 Token 相关字段常量，统一缓存命名规则。                                    |
-| `channel_setting.go` | Channel 级别的设置键，如 `proxy`、`force_format` 等。                          |
-| `context_key.go`     | 定义 `ContextKey` 类型以及在整个项目中使用的上下文键常量（请求时间、Token/Channel/User 相关信息等）。 |
-| `env.go`             | 环境配置相关的全局变量，在启动阶段根据配置文件或环境变量注入。                                     |
-| `finish_reason.go`   | OpenAI/GPT 请求返回的 `finish_reason` 字符串常量集合。                           |
-| `midjourney.go`      | Midjourney 相关错误码及动作(Action)常量与模型到动作的映射表。                            |
-| `setup.go`           | 标识项目是否已完成初始化安装 (`Setup` 布尔值)。                                       |
-| `task.go`            | 各种任务(Task)平台、动作常量及模型与动作映射表，如 Suno、Midjourney 等。                     |
-| `user_setting.go`    | 用户设置相关键常量以及通知类型(Email/Webhook)等。                                    |
-
-## 使用约定
-
-1. `constant` 包**只能被其他包引用**（import），**禁止在此包中引用项目内的其他自定义包**。如确有需要，仅允许引用 **Go 标准库**。
-2. 不允许在此目录内编写任何与业务流程、数据库操作、第三方服务调用等相关的逻辑代码。
-3. 新增类型时，请保持命名语义清晰，并在本 README 的 **当前文件** 表格中补充说明，确保团队成员能够快速了解其用途。
-
-> ⚠️ 违反以上约定将导致包之间产生不必要的耦合，影响代码可维护性与可测试性。请在提交代码前自行检查。

new-api/constant/api_type.go

@@ -1,37 +0,0 @@
-package constant
-
-const (
-	APITypeOpenAI = iota
-	APITypeAnthropic
-	APITypePaLM
-	APITypeBaidu
-	APITypeZhipu
-	APITypeAli
-	APITypeXunfei
-	APITypeAIProxyLibrary
-	APITypeTencent
-	APITypeGemini
-	APITypeZhipuV4
-	APITypeOllama
-	APITypePerplexity
-	APITypeAws
-	APITypeCohere
-	APITypeDify
-	APITypeJina
-	APITypeCloudflare
-	APITypeSiliconFlow
-	APITypeVertexAi
-	APITypeMistral
-	APITypeDeepSeek
-	APITypeMokaAI
-	APITypeVolcEngine
-	APITypeBaiduV2
-	APITypeOpenRouter
-	APITypeXinference
-	APITypeXai
-	APITypeCoze
-	APITypeJimeng
-     APITypeMoonshot
-     APITypeSubmodel
-     APITypeDummy    // this one is only for count, do not add any channel after this
-)

new-api/constant/azure.go

@@ -1,5 +0,0 @@
-package constant
-
-import "time"
-
-var AzureNoRemoveDotTime = time.Date(2025, time.May, 10, 0, 0, 0, 0, time.UTC).Unix()