feat: grok Usage Guidelines Violation Fee

controller/relay.go

@@ -167,8 +167,12 @@ func Relay(c *gin.Context, relayFormat types.RelayFormat) {
 
 	defer func() {
 		// Only return quota if downstream failed and quota was actually pre-consumed
-		if newAPIError != nil && relayInfo.FinalPreConsumedQuota != 0 {
-			service.ReturnPreConsumedQuota(c, relayInfo)
+		if newAPIError != nil {
+			newAPIError = service.NormalizeViolationFeeError(newAPIError)
+			if relayInfo.FinalPreConsumedQuota != 0 {
+				service.ReturnPreConsumedQuota(c, relayInfo)
+			}
+			service.ChargeViolationFeeIfNeeded(c, relayInfo, newAPIError)
 		}
 	}()
 
@@ -215,6 +219,8 @@ func Relay(c *gin.Context, relayFormat types.RelayFormat) {
 			return
 		}
 
+		newAPIError = service.NormalizeViolationFeeError(newAPIError)
+
 		processChannelError(c, *types.NewChannelError(channel.Id, channel.Type, channel.Name, channel.ChannelInfo.IsMultiKey, common.GetContextKeyString(c, constant.ContextKeyChannelKey), channel.GetAutoBan()), newAPIError)
 
 		if !shouldRetry(c, newAPIError, common.RetryTimes-retryParam.GetRetry()) {

service/violation_fee.go

@@ -0,0 +1,163 @@
+package service
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/QuantumNous/new-api/common"
+	"github.com/QuantumNous/new-api/logger"
+	"github.com/QuantumNous/new-api/model"
+	relaycommon "github.com/QuantumNous/new-api/relay/common"
+	"github.com/QuantumNous/new-api/setting/model_setting"
+	"github.com/QuantumNous/new-api/types"
+
+	"github.com/shopspring/decimal"
+
+	"github.com/gin-gonic/gin"
+)
+
+const (
+	ViolationFeeCodePrefix = "violation_fee."
+	CSAMViolationMarker    = "Failed check: SAFETY_CHECK_TYPE_CSAM"
+)
+
+func IsViolationFeeCode(code types.ErrorCode) bool {
+	return strings.HasPrefix(string(code), ViolationFeeCodePrefix)
+}
+
+func HasCSAMViolationMarker(err *types.NewAPIError) bool {
+	if err == nil {
+		return false
+	}
+	if strings.Contains(err.Error(), CSAMViolationMarker) {
+		return true
+	}
+	msg := err.ToOpenAIError().Message
+	return strings.Contains(msg, CSAMViolationMarker)
+}
+
+func WrapAsViolationFeeGrokCSAM(err *types.NewAPIError) *types.NewAPIError {
+	if err == nil {
+		return nil
+	}
+	oai := err.ToOpenAIError()
+	oai.Type = string(types.ErrorCodeViolationFeeGrokCSAM)
+	oai.Code = string(types.ErrorCodeViolationFeeGrokCSAM)
+	return types.WithOpenAIError(oai, err.StatusCode, types.ErrOptionWithSkipRetry())
+}
+
+// NormalizeViolationFeeError ensures:
+// - if the CSAM marker is present, error.code is set to a stable violation-fee code and skip-retry is enabled.
+// - if error.code already has the violation-fee prefix, skip-retry is enabled.
+//
+// It must be called before retry decision logic.
+func NormalizeViolationFeeError(err *types.NewAPIError) *types.NewAPIError {
+	if err == nil {
+		return nil
+	}
+
+	if HasCSAMViolationMarker(err) {
+		return WrapAsViolationFeeGrokCSAM(err)
+	}
+
+	if IsViolationFeeCode(err.GetErrorCode()) {
+		oai := err.ToOpenAIError()
+		return types.WithOpenAIError(oai, err.StatusCode, types.ErrOptionWithSkipRetry())
+	}
+
+	return err
+}
+
+func shouldChargeViolationFee(err *types.NewAPIError) bool {
+	if err == nil {
+		return false
+	}
+	if err.GetErrorCode() == types.ErrorCodeViolationFeeGrokCSAM {
+		return true
+	}
+	// In case some callers didn't normalize, keep a safety net.
+	return HasCSAMViolationMarker(err)
+}
+
+func calcViolationFeeQuota(amount, groupRatio float64) int {
+	if amount <= 0 {
+		return 0
+	}
+	if groupRatio <= 0 {
+		return 0
+	}
+	quota := decimal.NewFromFloat(amount).
+		Mul(decimal.NewFromFloat(common.QuotaPerUnit)).
+		Mul(decimal.NewFromFloat(groupRatio)).
+		Round(0).
+		IntPart()
+	if quota <= 0 {
+		return 0
+	}
+	return int(quota)
+}
+
+// ChargeViolationFeeIfNeeded charges an additional fee after the normal flow finishes (including refund).
+// It uses Grok fee settings as the fee policy.
+func ChargeViolationFeeIfNeeded(ctx *gin.Context, relayInfo *relaycommon.RelayInfo, apiErr *types.NewAPIError) bool {
+	if ctx == nil || relayInfo == nil || apiErr == nil {
+		return false
+	}
+	//if relayInfo.IsPlayground {
+	//	return false
+	//}
+	if !shouldChargeViolationFee(apiErr) {
+		return false
+	}
+
+	settings := model_setting.GetGrokSettings()
+	if settings == nil || !settings.ViolationDeductionEnabled {
+		return false
+	}
+
+	groupRatio := relayInfo.PriceData.GroupRatioInfo.GroupRatio
+	feeQuota := calcViolationFeeQuota(settings.ViolationDeductionAmount, groupRatio)
+	if feeQuota <= 0 {
+		return false
+	}
+
+	if err := PostConsumeQuota(relayInfo, feeQuota, 0, true); err != nil {
+		logger.LogError(ctx, fmt.Sprintf("failed to charge violation fee: %s", err.Error()))
+		return false
+	}
+
+	model.UpdateUserUsedQuotaAndRequestCount(relayInfo.UserId, feeQuota)
+	model.UpdateChannelUsedQuota(relayInfo.ChannelId, feeQuota)
+
+	useTimeSeconds := time.Now().Unix() - relayInfo.StartTime.Unix()
+	tokenName := ctx.GetString("token_name")
+	oai := apiErr.ToOpenAIError()
+
+	other := map[string]any{
+		"violation_fee":        true,
+		"violation_fee_code":   string(types.ErrorCodeViolationFeeGrokCSAM),
+		"fee_quota":            feeQuota,
+		"base_amount":          settings.ViolationDeductionAmount,
+		"group_ratio":          groupRatio,
+		"status_code":          apiErr.StatusCode,
+		"upstream_error_type":  oai.Type,
+		"upstream_error_code":  fmt.Sprintf("%v", oai.Code),
+		"violation_fee_marker": CSAMViolationMarker,
+	}
+
+	model.RecordConsumeLog(ctx, relayInfo.UserId, model.RecordConsumeLogParams{
+		ChannelId:      relayInfo.ChannelId,
+		ModelName:      relayInfo.OriginModelName,
+		TokenName:      tokenName,
+		Quota:          feeQuota,
+		Content:        "Violation fee charged",
+		TokenId:        relayInfo.TokenId,
+		UseTimeSeconds: int(useTimeSeconds),
+		IsStream:       relayInfo.IsStream,
+		Group:          relayInfo.UsingGroup,
+		Other:          other,
+	})
+
+	return true
+}

setting/model_setting/grok.go

@@ -0,0 +1,24 @@
+package model_setting
+
+import "github.com/QuantumNous/new-api/setting/config"
+
+// GrokSettings defines Grok model configuration.
+type GrokSettings struct {
+	ViolationDeductionEnabled bool    `json:"violation_deduction_enabled"`
+	ViolationDeductionAmount  float64 `json:"violation_deduction_amount"`
+}
+
+var defaultGrokSettings = GrokSettings{
+	ViolationDeductionEnabled: true,
+	ViolationDeductionAmount:  0.05,
+}
+
+var grokSettings = defaultGrokSettings
+
+func init() {
+	config.GlobalConfig.Register("grok", &grokSettings)
+}
+
+func GetGrokSettings() *GrokSettings {
+	return &grokSettings
+}

types/error.go

@@ -40,6 +40,7 @@ type ErrorCode string
 const (
 	ErrorCodeInvalidRequest         ErrorCode = "invalid_request"
 	ErrorCodeSensitiveWordsDetected ErrorCode = "sensitive_words_detected"
+	ErrorCodeViolationFeeGrokCSAM   ErrorCode = "violation_fee.grok.csam"
 
 	// new api error
 	ErrorCodeCountTokenFailed   ErrorCode = "count_token_failed"

web/src/components/settings/ModelSetting.jsx

@@ -25,6 +25,7 @@ import { useTranslation } from 'react-i18next';
 import SettingGeminiModel from '../../pages/Setting/Model/SettingGeminiModel';
 import SettingClaudeModel from '../../pages/Setting/Model/SettingClaudeModel';
 import SettingGlobalModel from '../../pages/Setting/Model/SettingGlobalModel';
+import SettingGrokModel from '../../pages/Setting/Model/SettingGrokModel';
 
 const ModelSetting = () => {
   const { t } = useTranslation();
@@ -44,6 +45,8 @@ const ModelSetting = () => {
     'general_setting.ping_interval_seconds': 60,
     'gemini.thinking_adapter_enabled': false,
     'gemini.thinking_adapter_budget_tokens_percentage': 0.6,
+    'grok.violation_deduction_enabled': true,
+    'grok.violation_deduction_amount': 0.05,
   });
 
   let [loading, setLoading] = useState(false);
@@ -117,6 +120,10 @@ const ModelSetting = () => {
         <Card style={{ marginTop: '10px' }}>
           <SettingClaudeModel options={inputs} refresh={onRefresh} />
         </Card>
+        {/* Grok */}
+        <Card style={{ marginTop: '10px' }}>
+          <SettingGrokModel options={inputs} refresh={onRefresh} />
+        </Card>
       </Spin>
     </>
   );

web/src/components/table/usage-logs/UsageLogsColumnDefs.jsx

@@ -61,6 +61,16 @@ const colors = [
   'yellow',
 ];
 
+function formatRatio(ratio) {
+  if (ratio === undefined || ratio === null) {
+    return '-';
+  }
+  if (typeof ratio === 'number') {
+    return ratio.toFixed(4);
+  }
+  return String(ratio);
+}
+
 // Render functions
 function renderType(type, t) {
   switch (type) {
@@ -541,6 +551,38 @@ export const getLogsColumns = ({
             </Typography.Paragraph>
           );
         }
+
+        if (
+          other?.violation_fee === true ||
+          Boolean(other?.violation_fee_code) ||
+          Boolean(other?.violation_fee_marker)
+        ) {
+          const feeQuota = other?.fee_quota ?? record?.quota;
+          const ratioText = formatRatio(other?.group_ratio);
+          const summary = [
+            t('违规扣费'),
+            `${t('分组倍率')}：${ratioText}`,
+            `${t('扣费')}：${renderQuota(feeQuota, 6)}`,
+            text ? `${t('详情')}：${text}` : null,
+          ]
+            .filter(Boolean)
+            .join('\n');
+          return (
+            <Typography.Paragraph
+              ellipsis={{
+                rows: 2,
+                showTooltip: {
+                  type: 'popover',
+                  opts: { style: { width: 240 } },
+                },
+              }}
+              style={{ maxWidth: 240, whiteSpace: 'pre-line' }}
+            >
+              {summary}
+            </Typography.Paragraph>
+          );
+        }
+
         let content = other?.claude
           ? renderModelPriceSimple(
               other.model_ratio,

web/src/helpers/log.js

@@ -18,9 +18,16 @@ For commercial licensing, please contact support@quantumnous.com
 */
 
 export function getLogOther(otherStr) {
-  if (otherStr === undefined || otherStr === '') {
-    otherStr = '{}';
+  if (otherStr === undefined || otherStr === null || otherStr === '') {
+    return {};
+  }
+  if (typeof otherStr === 'object') {
+    return otherStr;
+  }
+  try {
+    return JSON.parse(otherStr);
+  } catch (e) {
+    console.error(`Failed to parse record.other: "${otherStr}".`, e);
+    return null;
   }
-  let other = JSON.parse(otherStr);
-  return other;
 }