cneicy/new-api-custom
1
0 Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

feat: publish sanitized custom.97 source

Browse Source
This commit is contained in:
cneicy committed 2026-10-27 20:43:39 +08:00
1 parent 8e6ed0317b
commit 86c0276156
1022 files changed
+69903 -19207
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

relay/helper/price.go
+55 -45
View File
@@ -1,11 +1,12 @@
package helper
import (
"errors"
"fmt"
"strings"
"github.com/QuantumNous/new-api/common"
"github.com/QuantumNous/new-api/constant"
"github.com/QuantumNous/new-api/i18n"
"github.com/QuantumNous/new-api/logger"
"github.com/QuantumNous/new-api/model"
"github.com/QuantumNous/new-api/pkg/billingexpr"
@@ -14,6 +15,7 @@ import (
"github.com/QuantumNous/new-api/relaykit/relayconvert/reasoning"
"github.com/QuantumNous/new-api/relaykit/types"
"github.com/QuantumNous/new-api/setting/billing_setting"
"github.com/QuantumNous/new-api/setting/model_setting"
"github.com/QuantumNous/new-api/setting/operation_setting"
"github.com/QuantumNous/new-api/setting/ratio_setting"
hostreasoning "github.com/QuantumNous/new-api/setting/reasoning"
@@ -22,29 +24,17 @@ import (
"github.com/gin-gonic/gin"
)
func modelPriceNotConfiguredError(modelName string, userId int) error {
func modelPriceNotConfiguredError(c *gin.Context, modelName string, userId int) error {
key := i18n.MsgRelayModelPriceNotConfigured
if model.IsAdmin(userId) {
return fmt.Errorf(
"模型 %s 的价格未配置。请前往「系统设置 → 运营设置」开启自用模式，或在「系统设置 → 分组与模型定价设置」中为该模型配置价格；"+
"Model %s price not configured. Go to System Settings → Operation Settings to enable self-use mode, or configure the model price in System Settings → Group & Model Pricing.",
modelName, modelName,
)
key = i18n.MsgRelayModelPriceNotConfiguredAdmin
}
return fmt.Errorf(
"模型 %s 的价格尚未由管理员配置，暂时无法使用，请联系站点管理员开启该模型；"+
"Model %s has not been priced by the administrator yet. Please contact the site administrator to enable this model.",
modelName, modelName,
)
return errors.New(i18n.T(c, key, map[string]any{"Model": modelName}))
}
// https://docs.claude.com/en/docs/build-with-claude/prompt-caching#1-hour-cache-duration
const claudeCacheCreation1hMultiplier = 6 / 3.75
// defaultTieredPreConsumeMaxTokens is the fallback completion-token estimate
// used for tiered expression pre-consume when the client omits max_tokens, so
// the pre-consumed quota still reflects a plausible output cost in paid groups.
const defaultTieredPreConsumeMaxTokens = 8192
// HandleGroupRatio checks for "auto_group" in the context and updates the group ratio and relayInfo.UsingGroup if present
func HandleGroupRatio(ctx *gin.Context, relayInfo *relaycommon.RelayInfo) hosttypes.GroupRatioInfo {
if autoGroup, exists := ctx.Get("auto_group"); exists {
@@ -54,6 +44,16 @@ func HandleGroupRatio(ctx *gin.Context, relayInfo *relaycommon.RelayInfo) hostty
return model.EffectiveGroupRatio(ctx, relayInfo.UserGroup, relayInfo.UsingGroup)
}
func deepSeekOfficialGroupRatio(info *relaycommon.RelayInfo, ratio hosttypes.GroupRatioInfo) hosttypes.GroupRatioInfo {
if info == nil || info.UsingGroup != billing_setting.DeepSeekOfficialGroup {
return ratio
}
return hosttypes.GroupRatioInfo{
GroupRatio: billing_setting.DeepSeekOfficialGroupRatio,
GroupSpecialRatio: -1,
}
}
func ModelPriceHelper(c *gin.Context, info *relaycommon.RelayInfo, promptTokens int, meta *types.TokenCountMeta) (hosttypes.PriceData, error) {
if info != nil {
if matched := resolveBillingModelName(info.GetOriginModelName()); matched != "" && matched != info.OriginModelName {
@@ -65,10 +65,16 @@ func ModelPriceHelper(c *gin.Context, info *relaycommon.RelayInfo, promptTokens
groupRatioInfo := HandleGroupRatio(c, info)
if info.UsingGroup == billing_setting.DeepSeekOfficialGroup {
if _, ok := billing_setting.GetGroupBillingExpr(info.UsingGroup, billingModelName); ok {
groupRatioInfo = deepSeekOfficialGroupRatio(info, groupRatioInfo)
}
}
// Check if this model uses tiered_expr billing
_, hasGroupExpr := billing_setting.GetGroupBillingExpr(info.UsingGroup, billingModelName)
if hasGroupExpr || billing_setting.GetBillingMode(billingModelName) == billing_setting.BillingModeTieredExpr {
return modelPriceHelperTiered(c, info, billingModelName, promptTokens, meta, groupRatioInfo)
return modelPriceHelperTiered(c, info, billingModelName, promptTokens, groupRatioInfo)
}
var preConsumedQuota int
@@ -83,10 +89,11 @@ func ModelPriceHelper(c *gin.Context, info *relaycommon.RelayInfo, promptTokens
var audioCompletionRatio float64
var freeModel bool
if !usePrice {
preConsumedTokens := common.Max(promptTokens, common.PreConsumedQuota)
if meta.MaxTokens != 0 {
preConsumedTokens += meta.MaxTokens
preConsumeMultiplier, err := operation_setting.InputPreConsumeMultiplier()
if err != nil {
return hosttypes.PriceData{}, err
}
preConsumedTokens := float64(promptTokens) * preConsumeMultiplier
var success bool
var matchName string
modelRatio, success, matchName = ratio_setting.GetModelRatio(billingModelName)
@@ -96,7 +103,7 @@ func ModelPriceHelper(c *gin.Context, info *relaycommon.RelayInfo, promptTokens
acceptUnsetRatio = true
}
if !acceptUnsetRatio {
return hosttypes.PriceData{}, modelPriceNotConfiguredError(matchName, info.UserId)
return hosttypes.PriceData{}, modelPriceNotConfiguredError(c, matchName, info.UserId)
}
}
completionRatio = ratio_setting.GetCompletionRatio(billingModelName)
@@ -109,13 +116,13 @@ func ModelPriceHelper(c *gin.Context, info *relaycommon.RelayInfo, promptTokens
audioRatio = ratio_setting.GetAudioRatio(billingModelName)
audioCompletionRatio = ratio_setting.GetAudioCompletionRatio(billingModelName)
ratio := modelRatio * groupRatioInfo.GroupRatio
quota, err := common.QuotaFromFloatStrict(float64(preConsumedTokens) * ratio)
quota, err := common.QuotaFromFloatStrict(preConsumedTokens * ratio)
if err != nil {
return hosttypes.PriceData{}, err
}
preConsumedQuota = quota
if _, image := info.Request.(*dto.ImageRequest); image {
info.ImageQuotaBeforeGroup = float64(preConsumedTokens) * modelRatio
info.ImageQuotaBeforeGroup = preConsumedTokens * modelRatio
}
} else {
if meta.ImagePriceRatio != 0 {
@@ -167,25 +174,13 @@ func ModelPriceHelper(c *gin.Context, info *relaycommon.RelayInfo, promptTokens
}
}
if request, image := info.Request.(*dto.ImageRequest); image {
channelType := common.GetContextKeyInt(c, constant.ContextKeyChannelType)
count, err := request.ImageCount(channelType == constant.ChannelTypeAli)
count, err := request.ImageCount(false)
if err != nil {
return hosttypes.PriceData{}, err
}
if usePrice || channelType == constant.ChannelTypeAli {
if usePrice {
priceData.AddOtherRatio("n", float64(count))
}
if channelType == constant.ChannelTypeAli && request.BillingParameters != nil && request.BillingParameters.PromptExtend != nil && *request.BillingParameters.PromptExtend {
// Resolve only routing identity; do not initialize ChannelMeta on the
// real request, which also distinguishes the first channel attempt.
mapped := &relaycommon.RelayInfo{OriginModelName: info.OriginModelName, ChannelMeta: &relaycommon.ChannelMeta{UpstreamModelName: info.OriginModelName}}
if err := ModelMappedHelper(c, mapped, nil); err != nil {
return hosttypes.PriceData{}, err
}
if strings.Contains(mapped.UpstreamModelName, "z-image") {
priceData.AddOtherRatio("prompt_extend", common.ZImagePromptExtendMultiplier)
}
}
if !usePrice {
quota, err := common.QuotaFromFloatStrict(priceData.ApplyOtherRatiosToFloat(info.ImageQuotaBeforeGroup * groupRatioInfo.GroupRatio))
if err != nil {
@@ -232,7 +227,7 @@ func ModelPriceHelperPerCall(c *gin.Context, info *relaycommon.RelayInfo) (hostt
acceptUnsetRatio = true
}
if !ratioSuccess && !acceptUnsetRatio {
return hosttypes.PriceData{}, modelPriceNotConfiguredError(matchName, info.UserId)
return hosttypes.PriceData{}, modelPriceNotConfiguredError(c, matchName, info.UserId)
}
}
}
@@ -314,6 +309,11 @@ func resolveBillingModelName(origin string) string {
}
candidates = append(candidates, hostreasoning.CanonicalBillingModelNames(origin)...)
base := hostreasoning.BaseModelName(origin)
// DeepSeek thinking tails (-none/-low/-max) bill at the base model's price,
// with or without @ modifiers after them.
if deepSeekBase, _, _, ok := reasoning.ParseDeepSeekV4ThinkingSuffix(base); ok && !model_setting.ShouldPreserveThinkingSuffix(base) {
candidates = append(candidates, deepSeekBase)
}
candidates = append(candidates, base)
seen := make(map[string]struct{}, len(candidates))
@@ -337,19 +337,23 @@ func resolveBillingModelName(origin string) string {
return matched
}
func modelPriceHelperTiered(c *gin.Context, info *relaycommon.RelayInfo, billingModelName string, promptTokens int, meta *types.TokenCountMeta, groupRatioInfo hosttypes.GroupRatioInfo) (hosttypes.PriceData, error) {
func modelPriceHelperTiered(c *gin.Context, info *relaycommon.RelayInfo, billingModelName string, promptTokens int, groupRatioInfo hosttypes.GroupRatioInfo) (hosttypes.PriceData, error) {
exprStr, ok := billing_setting.GetBillingExprForGroup(info.UsingGroup, billingModelName)
if !ok {
return hosttypes.PriceData{}, fmt.Errorf("model %s is configured as tiered_expr but has no billing expression", billingModelName)
}
return modelPriceHelperTieredWithExpr(c, info, billingModelName, promptTokens, groupRatioInfo, exprStr)
}
func modelPriceHelperTieredWithExpr(c *gin.Context, info *relaycommon.RelayInfo, billingModelName string, promptTokens int, groupRatioInfo hosttypes.GroupRatioInfo, exprStr string) (hosttypes.PriceData, error) {
exprHash := billingexpr.ExprHashString(exprStr)
if info.RelayFormat == types.RelayFormatOpenAIRealtime && billingexpr.UsesFixedPricingByHash(exprStr, exprHash) {
return hosttypes.PriceData{}, fmt.Errorf("fixed pricing is not supported for Realtime requests")
}
estimatedCompletionTokens := meta.MaxTokens
if estimatedCompletionTokens == 0 && groupRatioInfo.GroupRatio != 0 {
estimatedCompletionTokens = defaultTieredPreConsumeMaxTokens
preConsumeMultiplier, err := operation_setting.InputPreConsumeMultiplier()
if err != nil {
return hosttypes.PriceData{}, err
}
requestInput, err := ResolveIncomingBillingExprRequestInput(c, info)
@@ -365,7 +369,7 @@ func modelPriceHelperTiered(c *gin.Context, info *relaycommon.RelayInfo, billing
rawCost, trace, err := billingexpr.RunExprByHashWithRequest(exprStr, exprHash, billingexpr.TokenParams{
P: float64(promptTokens),
C: float64(estimatedCompletionTokens),
C: 0,
Len: float64(promptTokens),
}, requestInput)
if err != nil {
@@ -374,6 +378,11 @@ func modelPriceHelperTiered(c *gin.Context, info *relaycommon.RelayInfo, billing
// Expression coefficients are $/1M tokens prices; convert to quota the same way per-call billing does.
quotaBeforeGroup := rawCost / 1_000_000 * common.QuotaPerUnit
// Scale the reservation, preserving the expression's context-length tier
// and leaving actual settlement and fixed request prices unchanged.
if trace.BillingUnit != billingexpr.BillingUnitRequest {
quotaBeforeGroup *= preConsumeMultiplier
}
preConsumedQuota, err := billingexpr.QuotaRoundStrict(quotaBeforeGroup * groupRatioInfo.GroupRatio)
if err != nil {
return hosttypes.PriceData{}, err
@@ -395,7 +404,8 @@ func modelPriceHelperTiered(c *gin.Context, info *relaycommon.RelayInfo, billing
ExprHash: exprHash,
GroupRatio: groupRatioInfo.GroupRatio,
EstimatedPromptTokens: promptTokens,
EstimatedCompletionTokens: estimatedCompletionTokens,
EstimatedCompletionTokens: 0,
PreConsumeMultiplier: preConsumeMultiplier,
EstimatedQuotaBeforeGroup: quotaBeforeGroup,
EstimatedQuotaAfterGroup: preConsumedQuota,
EstimatedTier: trace.MatchedTier,