|
- package common
-
- import (
- "errors"
- "fmt"
- "net/http"
- "regexp"
- "sort"
- "strconv"
- "strings"
-
- "github.com/QuantumNous/new-api/common"
- "github.com/QuantumNous/new-api/types"
- "github.com/samber/lo"
- "github.com/tidwall/gjson"
- "github.com/tidwall/sjson"
- )
-
- var negativeIndexRegexp = regexp.MustCompile(`\.(-\d+)`)
-
- const (
- paramOverrideContextRequestHeaders = "request_headers"
- paramOverrideContextHeaderOverride = "header_override"
- paramOverrideContextAuditRecorder = "__param_override_audit_recorder"
- )
-
- var errSourceHeaderNotFound = errors.New("source header does not exist")
-
- var paramOverrideKeyAuditPaths = map[string]struct{}{
- "model": {},
- "original_model": {},
- "upstream_model": {},
- "service_tier": {},
- "inference_geo": {},
- }
-
- type paramOverrideAuditRecorder struct {
- lines []string
- }
-
- type ConditionOperation struct {
- Path string `json:"path"` // JSON路径
- Mode string `json:"mode"` // full, prefix, suffix, contains, gt, gte, lt, lte
- Value interface{} `json:"value"` // 匹配的值
- Invert bool `json:"invert"` // 反选功能,true表示取反结果
- PassMissingKey bool `json:"pass_missing_key"` // 未获取到json key时的行为
- }
-
- type ParamOperation struct {
- Path string `json:"path"`
- Mode string `json:"mode"` // delete, set, move, copy, prepend, append, trim_prefix, trim_suffix, ensure_prefix, ensure_suffix, trim_space, to_lower, to_upper, replace, regex_replace, return_error, prune_objects, set_header, delete_header, copy_header, move_header, pass_headers, sync_fields
- Value interface{} `json:"value"`
- KeepOrigin bool `json:"keep_origin"`
- From string `json:"from,omitempty"`
- To string `json:"to,omitempty"`
- Conditions []ConditionOperation `json:"conditions,omitempty"` // 条件列表
- Logic string `json:"logic,omitempty"` // AND, OR (默认OR)
- }
-
- type ParamOverrideReturnError struct {
- Message string
- StatusCode int
- Code string
- Type string
- SkipRetry bool
- }
-
- func (e *ParamOverrideReturnError) Error() string {
- if e == nil {
- return "param override return error"
- }
- if e.Message == "" {
- return "param override return error"
- }
- return e.Message
- }
-
- func AsParamOverrideReturnError(err error) (*ParamOverrideReturnError, bool) {
- if err == nil {
- return nil, false
- }
- var target *ParamOverrideReturnError
- if errors.As(err, &target) {
- return target, true
- }
- return nil, false
- }
-
- func NewAPIErrorFromParamOverride(err *ParamOverrideReturnError) *types.NewAPIError {
- if err == nil {
- return types.NewError(
- errors.New("param override return error is nil"),
- types.ErrorCodeChannelParamOverrideInvalid,
- types.ErrOptionWithSkipRetry(),
- )
- }
-
- statusCode := err.StatusCode
- if statusCode < http.StatusContinue || statusCode > http.StatusNetworkAuthenticationRequired {
- statusCode = http.StatusBadRequest
- }
-
- errorCode := err.Code
- if strings.TrimSpace(errorCode) == "" {
- errorCode = string(types.ErrorCodeInvalidRequest)
- }
-
- errorType := err.Type
- if strings.TrimSpace(errorType) == "" {
- errorType = "invalid_request_error"
- }
-
- message := strings.TrimSpace(err.Message)
- if message == "" {
- message = "request blocked by param override"
- }
-
- opts := make([]types.NewAPIErrorOptions, 0, 1)
- if err.SkipRetry {
- opts = append(opts, types.ErrOptionWithSkipRetry())
- }
-
- return types.WithOpenAIError(types.OpenAIError{
- Message: message,
- Type: errorType,
- Code: errorCode,
- }, statusCode, opts...)
- }
-
- func ApplyParamOverride(jsonData []byte, paramOverride map[string]interface{}, conditionContext map[string]interface{}) ([]byte, error) {
- if len(paramOverride) == 0 {
- return jsonData, nil
- }
- auditRecorder := getParamOverrideAuditRecorder(conditionContext)
-
- // 尝试断言为操作格式
- if operations, ok := tryParseOperations(paramOverride); ok {
- legacyOverride := buildLegacyParamOverride(paramOverride)
- workingJSON := jsonData
- var err error
- if len(legacyOverride) > 0 {
- workingJSON, err = applyOperationsLegacy(workingJSON, legacyOverride, auditRecorder)
- if err != nil {
- return nil, err
- }
- }
-
- // 使用新方法
- result, err := applyOperations(string(workingJSON), operations, conditionContext)
- return []byte(result), err
- }
-
- // 直接使用旧方法
- return applyOperationsLegacy(jsonData, paramOverride, auditRecorder)
- }
-
- func buildLegacyParamOverride(paramOverride map[string]interface{}) map[string]interface{} {
- if len(paramOverride) == 0 {
- return nil
- }
- legacy := make(map[string]interface{}, len(paramOverride))
- for key, value := range paramOverride {
- if strings.EqualFold(strings.TrimSpace(key), "operations") {
- continue
- }
- legacy[key] = value
- }
- return legacy
- }
-
- func ApplyParamOverrideWithRelayInfo(jsonData []byte, info *RelayInfo) ([]byte, error) {
- paramOverride := getParamOverrideMap(info)
- if len(paramOverride) == 0 {
- return jsonData, nil
- }
-
- overrideCtx := BuildParamOverrideContext(info)
- var recorder *paramOverrideAuditRecorder
- if shouldEnableParamOverrideAudit(paramOverride) {
- recorder = ¶mOverrideAuditRecorder{}
- overrideCtx[paramOverrideContextAuditRecorder] = recorder
- }
- result, err := ApplyParamOverride(jsonData, paramOverride, overrideCtx)
- if err != nil {
- return nil, err
- }
- syncRuntimeHeaderOverrideFromContext(info, overrideCtx)
- if info != nil {
- if recorder != nil {
- info.ParamOverrideAudit = recorder.lines
- } else {
- info.ParamOverrideAudit = nil
- }
- }
- return result, nil
- }
-
- func shouldEnableParamOverrideAudit(paramOverride map[string]interface{}) bool {
- if common.DebugEnabled {
- return true
- }
- if len(paramOverride) == 0 {
- return false
- }
- if operations, ok := tryParseOperations(paramOverride); ok {
- for _, operation := range operations {
- if shouldAuditParamPath(strings.TrimSpace(operation.Path)) ||
- shouldAuditParamPath(strings.TrimSpace(operation.To)) {
- return true
- }
- }
- for key := range buildLegacyParamOverride(paramOverride) {
- if shouldAuditParamPath(strings.TrimSpace(key)) {
- return true
- }
- }
- return false
- }
- for key := range paramOverride {
- if shouldAuditParamPath(strings.TrimSpace(key)) {
- return true
- }
- }
- return false
- }
-
- func getParamOverrideAuditRecorder(context map[string]interface{}) *paramOverrideAuditRecorder {
- if context == nil {
- return nil
- }
- recorder, _ := context[paramOverrideContextAuditRecorder].(*paramOverrideAuditRecorder)
- return recorder
- }
-
- func (r *paramOverrideAuditRecorder) recordOperation(mode, path, from, to string, value interface{}) {
- if r == nil {
- return
- }
- line := buildParamOverrideAuditLine(mode, path, from, to, value)
- if line == "" {
- return
- }
- if lo.Contains(r.lines, line) {
- return
- }
- r.lines = append(r.lines, line)
- }
-
- func shouldAuditParamPath(path string) bool {
- path = strings.TrimSpace(path)
- if path == "" {
- return false
- }
- if common.DebugEnabled {
- return true
- }
- _, ok := paramOverrideKeyAuditPaths[path]
- return ok
- }
-
- func shouldAuditOperation(mode, path, from, to string) bool {
- if common.DebugEnabled {
- return true
- }
- for _, candidate := range []string{path, to} {
- if shouldAuditParamPath(candidate) {
- return true
- }
- }
- return false
- }
-
- func formatParamOverrideAuditValue(value interface{}) string {
- switch typed := value.(type) {
- case nil:
- return "<empty>"
- case string:
- return typed
- default:
- return common.GetJsonString(typed)
- }
- }
-
- func buildParamOverrideAuditLine(mode, path, from, to string, value interface{}) string {
- mode = strings.TrimSpace(mode)
- path = strings.TrimSpace(path)
- from = strings.TrimSpace(from)
- to = strings.TrimSpace(to)
-
- if !shouldAuditOperation(mode, path, from, to) {
- return ""
- }
-
- switch mode {
- case "set":
- if path == "" {
- return ""
- }
- return fmt.Sprintf("set %s = %s", path, formatParamOverrideAuditValue(value))
- case "delete":
- if path == "" {
- return ""
- }
- return fmt.Sprintf("delete %s", path)
- case "copy":
- if from == "" || to == "" {
- return ""
- }
- return fmt.Sprintf("copy %s -> %s", from, to)
- case "move":
- if from == "" || to == "" {
- return ""
- }
- return fmt.Sprintf("move %s -> %s", from, to)
- case "prepend":
- if path == "" {
- return ""
- }
- return fmt.Sprintf("prepend %s with %s", path, formatParamOverrideAuditValue(value))
- case "append":
- if path == "" {
- return ""
- }
- return fmt.Sprintf("append %s with %s", path, formatParamOverrideAuditValue(value))
- case "trim_prefix", "trim_suffix", "ensure_prefix", "ensure_suffix":
- if path == "" {
- return ""
- }
- return fmt.Sprintf("%s %s with %s", mode, path, formatParamOverrideAuditValue(value))
- case "trim_space", "to_lower", "to_upper":
- if path == "" {
- return ""
- }
- return fmt.Sprintf("%s %s", mode, path)
- case "replace", "regex_replace":
- if path == "" {
- return ""
- }
- return fmt.Sprintf("%s %s from %s to %s", mode, path, from, to)
- case "set_header":
- if path == "" {
- return ""
- }
- return fmt.Sprintf("set_header %s = %s", path, formatParamOverrideAuditValue(value))
- case "delete_header":
- if path == "" {
- return ""
- }
- return fmt.Sprintf("delete_header %s", path)
- case "copy_header", "move_header":
- if from == "" || to == "" {
- return ""
- }
- return fmt.Sprintf("%s %s -> %s", mode, from, to)
- case "pass_headers":
- return fmt.Sprintf("pass_headers %s", formatParamOverrideAuditValue(value))
- case "sync_fields":
- if from == "" || to == "" {
- return ""
- }
- return fmt.Sprintf("sync_fields %s -> %s", from, to)
- case "return_error":
- return fmt.Sprintf("return_error %s", formatParamOverrideAuditValue(value))
- default:
- if path == "" {
- return mode
- }
- return fmt.Sprintf("%s %s", mode, path)
- }
- }
-
- func getParamOverrideMap(info *RelayInfo) map[string]interface{} {
- if info == nil || info.ChannelMeta == nil {
- return nil
- }
- return info.ChannelMeta.ParamOverride
- }
-
- func getHeaderOverrideMap(info *RelayInfo) map[string]interface{} {
- if info == nil || info.ChannelMeta == nil {
- return nil
- }
- return info.ChannelMeta.HeadersOverride
- }
-
- func sanitizeHeaderOverrideMap(source map[string]interface{}) map[string]interface{} {
- if len(source) == 0 {
- return map[string]interface{}{}
- }
- target := make(map[string]interface{}, len(source))
- for key, value := range source {
- normalizedKey := normalizeHeaderContextKey(key)
- if normalizedKey == "" {
- continue
- }
- normalizedValue := strings.TrimSpace(fmt.Sprintf("%v", value))
- if normalizedValue == "" {
- if isHeaderPassthroughRuleKeyForOverride(normalizedKey) {
- target[normalizedKey] = ""
- }
- continue
- }
- target[normalizedKey] = normalizedValue
- }
- return target
- }
-
- func isHeaderPassthroughRuleKeyForOverride(key string) bool {
- key = strings.TrimSpace(strings.ToLower(key))
- if key == "" {
- return false
- }
- if key == "*" {
- return true
- }
- return strings.HasPrefix(key, "re:") || strings.HasPrefix(key, "regex:")
- }
-
- func GetEffectiveHeaderOverride(info *RelayInfo) map[string]interface{} {
- if info == nil {
- return map[string]interface{}{}
- }
- if info.UseRuntimeHeadersOverride {
- return sanitizeHeaderOverrideMap(info.RuntimeHeadersOverride)
- }
- return sanitizeHeaderOverrideMap(getHeaderOverrideMap(info))
- }
-
- func tryParseOperations(paramOverride map[string]interface{}) ([]ParamOperation, bool) {
- // 检查是否包含 "operations" 字段
- opsValue, exists := paramOverride["operations"]
- if !exists {
- return nil, false
- }
-
- var opMaps []map[string]interface{}
- switch ops := opsValue.(type) {
- case []interface{}:
- opMaps = make([]map[string]interface{}, 0, len(ops))
- for _, op := range ops {
- opMap, ok := op.(map[string]interface{})
- if !ok {
- return nil, false
- }
- opMaps = append(opMaps, opMap)
- }
- case []map[string]interface{}:
- opMaps = ops
- default:
- return nil, false
- }
-
- operations := make([]ParamOperation, 0, len(opMaps))
- for _, opMap := range opMaps {
- operation := ParamOperation{}
-
- // 断言必要字段
- if path, ok := opMap["path"].(string); ok {
- operation.Path = path
- }
- if mode, ok := opMap["mode"].(string); ok {
- operation.Mode = mode
- } else {
- return nil, false // mode 是必需的
- }
-
- // 可选字段
- if value, exists := opMap["value"]; exists {
- operation.Value = value
- }
- if keepOrigin, ok := opMap["keep_origin"].(bool); ok {
- operation.KeepOrigin = keepOrigin
- }
- if from, ok := opMap["from"].(string); ok {
- operation.From = from
- }
- if to, ok := opMap["to"].(string); ok {
- operation.To = to
- }
- if logic, ok := opMap["logic"].(string); ok {
- operation.Logic = logic
- } else {
- operation.Logic = "OR" // 默认为OR
- }
-
- // 解析条件
- if conditions, exists := opMap["conditions"]; exists {
- parsedConditions, err := parseConditionOperations(conditions)
- if err != nil {
- return nil, false
- }
- operation.Conditions = append(operation.Conditions, parsedConditions...)
- }
-
- operations = append(operations, operation)
- }
- return operations, true
- }
-
- func checkConditions(jsonStr, contextJSON string, conditions []ConditionOperation, logic string) (bool, error) {
- if len(conditions) == 0 {
- return true, nil // 没有条件,直接通过
- }
- results := make([]bool, len(conditions))
- for i, condition := range conditions {
- result, err := checkSingleCondition(jsonStr, contextJSON, condition)
- if err != nil {
- return false, err
- }
- results[i] = result
- }
-
- if strings.ToUpper(logic) == "AND" {
- return lo.EveryBy(results, func(item bool) bool { return item }), nil
- }
- return lo.SomeBy(results, func(item bool) bool { return item }), nil
- }
-
- func checkSingleCondition(jsonStr, contextJSON string, condition ConditionOperation) (bool, error) {
- // 处理负数索引
- path := processNegativeIndex(jsonStr, condition.Path)
- value := gjson.Get(jsonStr, path)
- if !value.Exists() && contextJSON != "" {
- value = gjson.Get(contextJSON, condition.Path)
- }
- if !value.Exists() {
- if condition.PassMissingKey {
- return true, nil
- }
- return false, nil
- }
-
- // 利用gjson的类型解析
- targetBytes, err := common.Marshal(condition.Value)
- if err != nil {
- return false, fmt.Errorf("failed to marshal condition value: %v", err)
- }
- targetValue := gjson.ParseBytes(targetBytes)
-
- result, err := compareGjsonValues(value, targetValue, strings.ToLower(condition.Mode))
- if err != nil {
- return false, fmt.Errorf("comparison failed for path %s: %v", condition.Path, err)
- }
-
- if condition.Invert {
- result = !result
- }
- return result, nil
- }
-
- func processNegativeIndex(jsonStr string, path string) string {
- matches := negativeIndexRegexp.FindAllStringSubmatch(path, -1)
-
- if len(matches) == 0 {
- return path
- }
-
- result := path
- for _, match := range matches {
- negIndex := match[1]
- index, _ := strconv.Atoi(negIndex)
-
- arrayPath := strings.Split(path, negIndex)[0]
- if strings.HasSuffix(arrayPath, ".") {
- arrayPath = arrayPath[:len(arrayPath)-1]
- }
-
- array := gjson.Get(jsonStr, arrayPath)
- if array.IsArray() {
- length := len(array.Array())
- actualIndex := length + index
- if actualIndex >= 0 && actualIndex < length {
- result = strings.Replace(result, match[0], "."+strconv.Itoa(actualIndex), 1)
- }
- }
- }
-
- return result
- }
-
- // compareGjsonValues 直接比较两个gjson.Result,支持所有比较模式
- func compareGjsonValues(jsonValue, targetValue gjson.Result, mode string) (bool, error) {
- switch mode {
- case "full":
- return compareEqual(jsonValue, targetValue)
- case "prefix":
- return strings.HasPrefix(jsonValue.String(), targetValue.String()), nil
- case "suffix":
- return strings.HasSuffix(jsonValue.String(), targetValue.String()), nil
- case "contains":
- return strings.Contains(jsonValue.String(), targetValue.String()), nil
- case "gt":
- return compareNumeric(jsonValue, targetValue, "gt")
- case "gte":
- return compareNumeric(jsonValue, targetValue, "gte")
- case "lt":
- return compareNumeric(jsonValue, targetValue, "lt")
- case "lte":
- return compareNumeric(jsonValue, targetValue, "lte")
- default:
- return false, fmt.Errorf("unsupported comparison mode: %s", mode)
- }
- }
-
- func compareEqual(jsonValue, targetValue gjson.Result) (bool, error) {
- // 对null值特殊处理:两个都是null返回true,一个是null另一个不是返回false
- if jsonValue.Type == gjson.Null || targetValue.Type == gjson.Null {
- return jsonValue.Type == gjson.Null && targetValue.Type == gjson.Null, nil
- }
-
- // 对布尔值特殊处理
- if (jsonValue.Type == gjson.True || jsonValue.Type == gjson.False) &&
- (targetValue.Type == gjson.True || targetValue.Type == gjson.False) {
- return jsonValue.Bool() == targetValue.Bool(), nil
- }
-
- // 如果类型不同,报错
- if jsonValue.Type != targetValue.Type {
- return false, fmt.Errorf("compare for different types, got %v and %v", jsonValue.Type, targetValue.Type)
- }
-
- switch jsonValue.Type {
- case gjson.True, gjson.False:
- return jsonValue.Bool() == targetValue.Bool(), nil
- case gjson.Number:
- return jsonValue.Num == targetValue.Num, nil
- case gjson.String:
- return jsonValue.String() == targetValue.String(), nil
- default:
- return jsonValue.String() == targetValue.String(), nil
- }
- }
-
- func compareNumeric(jsonValue, targetValue gjson.Result, operator string) (bool, error) {
- // 只有数字类型才支持数值比较
- if jsonValue.Type != gjson.Number || targetValue.Type != gjson.Number {
- return false, fmt.Errorf("numeric comparison requires both values to be numbers, got %v and %v", jsonValue.Type, targetValue.Type)
- }
-
- jsonNum := jsonValue.Num
- targetNum := targetValue.Num
-
- switch operator {
- case "gt":
- return jsonNum > targetNum, nil
- case "gte":
- return jsonNum >= targetNum, nil
- case "lt":
- return jsonNum < targetNum, nil
- case "lte":
- return jsonNum <= targetNum, nil
- default:
- return false, fmt.Errorf("unsupported numeric operator: %s", operator)
- }
- }
-
- // applyOperationsLegacy 原参数覆盖方法
- func applyOperationsLegacy(jsonData []byte, paramOverride map[string]interface{}, auditRecorder *paramOverrideAuditRecorder) ([]byte, error) {
- reqMap := make(map[string]interface{})
- err := common.Unmarshal(jsonData, &reqMap)
- if err != nil {
- return nil, err
- }
-
- for key, value := range paramOverride {
- reqMap[key] = value
- auditRecorder.recordOperation("set", key, "", "", value)
- }
-
- return common.Marshal(reqMap)
- }
-
- func applyOperations(jsonStr string, operations []ParamOperation, conditionContext map[string]interface{}) (string, error) {
- context := ensureContextMap(conditionContext)
- auditRecorder := getParamOverrideAuditRecorder(context)
- contextJSON, err := marshalContextJSON(context)
- if err != nil {
- return "", fmt.Errorf("failed to marshal condition context: %v", err)
- }
-
- result := jsonStr
- for _, op := range operations {
- // 检查条件是否满足
- ok, err := checkConditions(result, contextJSON, op.Conditions, op.Logic)
- if err != nil {
- return "", err
- }
- if !ok {
- continue // 条件不满足,跳过当前操作
- }
- // 处理路径中的负数索引
- opPath := processNegativeIndex(result, op.Path)
- var opPaths []string
- if isPathBasedOperation(op.Mode) {
- opPaths, err = resolveOperationPaths(result, opPath)
- if err != nil {
- return "", err
- }
- if len(opPaths) == 0 {
- continue
- }
- }
-
- switch op.Mode {
- case "delete":
- for _, path := range opPaths {
- result, err = deleteValue(result, path)
- if err != nil {
- break
- }
- auditRecorder.recordOperation("delete", path, "", "", nil)
- }
- case "set":
- for _, path := range opPaths {
- if op.KeepOrigin && gjson.Get(result, path).Exists() {
- continue
- }
- result, err = sjson.Set(result, path, op.Value)
- if err != nil {
- break
- }
- auditRecorder.recordOperation("set", path, "", "", op.Value)
- }
- case "move":
- opFrom := processNegativeIndex(result, op.From)
- opTo := processNegativeIndex(result, op.To)
- result, err = moveValue(result, opFrom, opTo)
- if err == nil {
- auditRecorder.recordOperation("move", "", opFrom, opTo, nil)
- }
- case "copy":
- if op.From == "" || op.To == "" {
- return "", fmt.Errorf("copy from/to is required")
- }
- opFrom := processNegativeIndex(result, op.From)
- opTo := processNegativeIndex(result, op.To)
- result, err = copyValue(result, opFrom, opTo)
- if err == nil {
- auditRecorder.recordOperation("copy", "", opFrom, opTo, nil)
- }
- case "prepend":
- for _, path := range opPaths {
- result, err = modifyValue(result, path, op.Value, op.KeepOrigin, true)
- if err != nil {
- break
- }
- auditRecorder.recordOperation("prepend", path, "", "", op.Value)
- }
- case "append":
- for _, path := range opPaths {
- result, err = modifyValue(result, path, op.Value, op.KeepOrigin, false)
- if err != nil {
- break
- }
- auditRecorder.recordOperation("append", path, "", "", op.Value)
- }
- case "trim_prefix":
- for _, path := range opPaths {
- result, err = trimStringValue(result, path, op.Value, true)
- if err != nil {
- break
- }
- auditRecorder.recordOperation("trim_prefix", path, "", "", op.Value)
- }
- case "trim_suffix":
- for _, path := range opPaths {
- result, err = trimStringValue(result, path, op.Value, false)
- if err != nil {
- break
- }
- auditRecorder.recordOperation("trim_suffix", path, "", "", op.Value)
- }
- case "ensure_prefix":
- for _, path := range opPaths {
- result, err = ensureStringAffix(result, path, op.Value, true)
- if err != nil {
- break
- }
- auditRecorder.recordOperation("ensure_prefix", path, "", "", op.Value)
- }
- case "ensure_suffix":
- for _, path := range opPaths {
- result, err = ensureStringAffix(result, path, op.Value, false)
- if err != nil {
- break
- }
- auditRecorder.recordOperation("ensure_suffix", path, "", "", op.Value)
- }
- case "trim_space":
- for _, path := range opPaths {
- result, err = transformStringValue(result, path, strings.TrimSpace)
- if err != nil {
- break
- }
- auditRecorder.recordOperation("trim_space", path, "", "", nil)
- }
- case "to_lower":
- for _, path := range opPaths {
- result, err = transformStringValue(result, path, strings.ToLower)
- if err != nil {
- break
- }
- auditRecorder.recordOperation("to_lower", path, "", "", nil)
- }
- case "to_upper":
- for _, path := range opPaths {
- result, err = transformStringValue(result, path, strings.ToUpper)
- if err != nil {
- break
- }
- auditRecorder.recordOperation("to_upper", path, "", "", nil)
- }
- case "replace":
- for _, path := range opPaths {
- result, err = replaceStringValue(result, path, op.From, op.To)
- if err != nil {
- break
- }
- auditRecorder.recordOperation("replace", path, op.From, op.To, nil)
- }
- case "regex_replace":
- for _, path := range opPaths {
- result, err = regexReplaceStringValue(result, path, op.From, op.To)
- if err != nil {
- break
- }
- auditRecorder.recordOperation("regex_replace", path, op.From, op.To, nil)
- }
- case "return_error":
- auditRecorder.recordOperation("return_error", op.Path, "", "", op.Value)
- returnErr, parseErr := parseParamOverrideReturnError(op.Value)
- if parseErr != nil {
- return "", parseErr
- }
- return "", returnErr
- case "prune_objects":
- for _, path := range opPaths {
- result, err = pruneObjects(result, path, contextJSON, op.Value)
- if err != nil {
- break
- }
- }
- case "set_header":
- err = setHeaderOverrideInContext(context, op.Path, op.Value, op.KeepOrigin)
- if err == nil {
- auditRecorder.recordOperation("set_header", op.Path, "", "", op.Value)
- contextJSON, err = marshalContextJSON(context)
- }
- case "delete_header":
- err = deleteHeaderOverrideInContext(context, op.Path)
- if err == nil {
- auditRecorder.recordOperation("delete_header", op.Path, "", "", nil)
- contextJSON, err = marshalContextJSON(context)
- }
- case "copy_header":
- sourceHeader := strings.TrimSpace(op.From)
- targetHeader := strings.TrimSpace(op.To)
- if sourceHeader == "" {
- sourceHeader = strings.TrimSpace(op.Path)
- }
- if targetHeader == "" {
- targetHeader = strings.TrimSpace(op.Path)
- }
- err = copyHeaderInContext(context, sourceHeader, targetHeader, op.KeepOrigin)
- if errors.Is(err, errSourceHeaderNotFound) {
- err = nil
- }
- if err == nil {
- auditRecorder.recordOperation("copy_header", "", sourceHeader, targetHeader, nil)
- contextJSON, err = marshalContextJSON(context)
- }
- case "move_header":
- sourceHeader := strings.TrimSpace(op.From)
- targetHeader := strings.TrimSpace(op.To)
- if sourceHeader == "" {
- sourceHeader = strings.TrimSpace(op.Path)
- }
- if targetHeader == "" {
- targetHeader = strings.TrimSpace(op.Path)
- }
- err = moveHeaderInContext(context, sourceHeader, targetHeader, op.KeepOrigin)
- if errors.Is(err, errSourceHeaderNotFound) {
- err = nil
- }
- if err == nil {
- auditRecorder.recordOperation("move_header", "", sourceHeader, targetHeader, nil)
- contextJSON, err = marshalContextJSON(context)
- }
- case "pass_headers":
- headerNames, parseErr := parseHeaderPassThroughNames(op.Value)
- if parseErr != nil {
- return "", parseErr
- }
- for _, headerName := range headerNames {
- if err = copyHeaderInContext(context, headerName, headerName, op.KeepOrigin); err != nil {
- if errors.Is(err, errSourceHeaderNotFound) {
- err = nil
- continue
- }
- break
- }
- }
- if err == nil {
- auditRecorder.recordOperation("pass_headers", "", "", "", headerNames)
- contextJSON, err = marshalContextJSON(context)
- }
- case "sync_fields":
- result, err = syncFieldsBetweenTargets(result, context, op.From, op.To)
- if err == nil {
- auditRecorder.recordOperation("sync_fields", "", op.From, op.To, nil)
- contextJSON, err = marshalContextJSON(context)
- }
- default:
- return "", fmt.Errorf("unknown operation: %s", op.Mode)
- }
- if err != nil {
- return "", fmt.Errorf("operation %s failed: %w", op.Mode, err)
- }
- }
- return result, nil
- }
-
- func parseParamOverrideReturnError(value interface{}) (*ParamOverrideReturnError, error) {
- result := &ParamOverrideReturnError{
- StatusCode: http.StatusBadRequest,
- Code: string(types.ErrorCodeInvalidRequest),
- Type: "invalid_request_error",
- SkipRetry: true,
- }
-
- switch raw := value.(type) {
- case nil:
- return nil, fmt.Errorf("return_error value is required")
- case string:
- result.Message = strings.TrimSpace(raw)
- case map[string]interface{}:
- if message, ok := raw["message"].(string); ok {
- result.Message = strings.TrimSpace(message)
- }
- if result.Message == "" {
- if message, ok := raw["msg"].(string); ok {
- result.Message = strings.TrimSpace(message)
- }
- }
-
- if code, exists := raw["code"]; exists {
- codeStr := strings.TrimSpace(fmt.Sprintf("%v", code))
- if codeStr != "" {
- result.Code = codeStr
- }
- }
- if errType, ok := raw["type"].(string); ok {
- errType = strings.TrimSpace(errType)
- if errType != "" {
- result.Type = errType
- }
- }
- if skipRetry, ok := raw["skip_retry"].(bool); ok {
- result.SkipRetry = skipRetry
- }
-
- if statusCodeRaw, exists := raw["status_code"]; exists {
- statusCode, ok := parseOverrideInt(statusCodeRaw)
- if !ok {
- return nil, fmt.Errorf("return_error status_code must be an integer")
- }
- result.StatusCode = statusCode
- } else if statusRaw, exists := raw["status"]; exists {
- statusCode, ok := parseOverrideInt(statusRaw)
- if !ok {
- return nil, fmt.Errorf("return_error status must be an integer")
- }
- result.StatusCode = statusCode
- }
- default:
- return nil, fmt.Errorf("return_error value must be string or object")
- }
-
- if result.Message == "" {
- return nil, fmt.Errorf("return_error message is required")
- }
- if result.StatusCode < http.StatusContinue || result.StatusCode > http.StatusNetworkAuthenticationRequired {
- return nil, fmt.Errorf("return_error status code out of range: %d", result.StatusCode)
- }
-
- return result, nil
- }
-
- func parseOverrideInt(v interface{}) (int, bool) {
- switch value := v.(type) {
- case int:
- return value, true
- case float64:
- if value != float64(int(value)) {
- return 0, false
- }
- return int(value), true
- default:
- return 0, false
- }
- }
-
- func ensureContextMap(conditionContext map[string]interface{}) map[string]interface{} {
- if conditionContext != nil {
- return conditionContext
- }
- return make(map[string]interface{})
- }
-
- func marshalContextJSON(context map[string]interface{}) (string, error) {
- if context == nil || len(context) == 0 {
- return "", nil
- }
- ctxBytes, err := common.Marshal(context)
- if err != nil {
- return "", err
- }
- return string(ctxBytes), nil
- }
-
- func setHeaderOverrideInContext(context map[string]interface{}, headerName string, value interface{}, keepOrigin bool) error {
- headerName = normalizeHeaderContextKey(headerName)
- if headerName == "" {
- return fmt.Errorf("header name is required")
- }
-
- rawHeaders := ensureMapKeyInContext(context, paramOverrideContextHeaderOverride)
- if keepOrigin {
- if existing, ok := rawHeaders[headerName]; ok {
- existingValue := strings.TrimSpace(fmt.Sprintf("%v", existing))
- if existingValue != "" {
- return nil
- }
- }
- }
-
- headerValue, hasValue, err := resolveHeaderOverrideValue(context, headerName, value)
- if err != nil {
- return err
- }
- if !hasValue {
- delete(rawHeaders, headerName)
- return nil
- }
-
- rawHeaders[headerName] = headerValue
- return nil
- }
-
- func resolveHeaderOverrideValue(context map[string]interface{}, headerName string, value interface{}) (string, bool, error) {
- if value == nil {
- return "", false, fmt.Errorf("header value is required")
- }
-
- if mapping, ok := value.(map[string]interface{}); ok {
- return resolveHeaderOverrideValueByMapping(context, headerName, mapping)
- }
- if mapping, ok := value.(map[string]string); ok {
- converted := make(map[string]interface{}, len(mapping))
- for key, item := range mapping {
- converted[key] = item
- }
- return resolveHeaderOverrideValueByMapping(context, headerName, converted)
- }
-
- headerValue := strings.TrimSpace(fmt.Sprintf("%v", value))
- if headerValue == "" {
- return "", false, nil
- }
- return headerValue, true, nil
- }
-
- func resolveHeaderOverrideValueByMapping(context map[string]interface{}, headerName string, mapping map[string]interface{}) (string, bool, error) {
- if len(mapping) == 0 {
- return "", false, fmt.Errorf("header value mapping cannot be empty")
- }
-
- appendTokens, err := parseHeaderAppendTokens(mapping)
- if err != nil {
- return "", false, err
- }
- keepOnlyDeclared := parseHeaderKeepOnlyDeclared(mapping)
-
- sourceValue, exists := getHeaderValueFromContext(context, headerName)
- sourceTokens := make([]string, 0)
- if exists {
- sourceTokens = splitHeaderListValue(sourceValue)
- }
-
- wildcardValue, hasWildcard := mapping["*"]
- resultTokens := make([]string, 0, len(sourceTokens)+len(appendTokens))
- for _, token := range sourceTokens {
- replacementRaw, hasReplacement := mapping[token]
- if !hasReplacement && hasWildcard && !keepOnlyDeclared {
- replacementRaw = wildcardValue
- hasReplacement = true
- }
- if !hasReplacement {
- if keepOnlyDeclared {
- continue
- }
- resultTokens = append(resultTokens, token)
- continue
- }
- replacementTokens, err := parseHeaderReplacementTokens(replacementRaw)
- if err != nil {
- return "", false, err
- }
- resultTokens = append(resultTokens, replacementTokens...)
- }
-
- resultTokens = append(resultTokens, appendTokens...)
- resultTokens = lo.Uniq(resultTokens)
- if len(resultTokens) == 0 {
- return "", false, nil
- }
- return strings.Join(resultTokens, ","), true, nil
- }
-
- func parseHeaderAppendTokens(mapping map[string]interface{}) ([]string, error) {
- appendRaw, ok := mapping["$append"]
- if !ok {
- return nil, nil
- }
- return parseHeaderReplacementTokens(appendRaw)
- }
-
- func parseHeaderKeepOnlyDeclared(mapping map[string]interface{}) bool {
- keepOnlyDeclaredRaw, ok := mapping["$keep_only_declared"]
- if !ok {
- return false
- }
- keepOnlyDeclared, ok := keepOnlyDeclaredRaw.(bool)
- if !ok {
- return false
- }
- return keepOnlyDeclared
- }
-
- func parseHeaderReplacementTokens(value interface{}) ([]string, error) {
- switch raw := value.(type) {
- case nil:
- return nil, nil
- case string:
- return splitHeaderListValue(raw), nil
- case []string:
- tokens := make([]string, 0, len(raw))
- for _, item := range raw {
- tokens = append(tokens, splitHeaderListValue(item)...)
- }
- return lo.Uniq(tokens), nil
- case []interface{}:
- tokens := make([]string, 0, len(raw))
- for _, item := range raw {
- itemTokens, err := parseHeaderReplacementTokens(item)
- if err != nil {
- return nil, err
- }
- tokens = append(tokens, itemTokens...)
- }
- return lo.Uniq(tokens), nil
- case map[string]interface{}, map[string]string:
- return nil, fmt.Errorf("header replacement value must be string, array or null")
- default:
- token := strings.TrimSpace(fmt.Sprintf("%v", raw))
- if token == "" {
- return nil, nil
- }
- return []string{token}, nil
- }
- }
-
- func splitHeaderListValue(raw string) []string {
- items := strings.Split(raw, ",")
- return lo.FilterMap(items, func(item string, _ int) (string, bool) {
- token := strings.TrimSpace(item)
- if token == "" {
- return "", false
- }
- return token, true
- })
- }
-
- func copyHeaderInContext(context map[string]interface{}, fromHeader, toHeader string, keepOrigin bool) error {
- fromHeader = normalizeHeaderContextKey(fromHeader)
- toHeader = normalizeHeaderContextKey(toHeader)
- if fromHeader == "" || toHeader == "" {
- return fmt.Errorf("copy_header from/to is required")
- }
- value, exists := getHeaderValueFromContext(context, fromHeader)
- if !exists {
- return fmt.Errorf("%w: %s", errSourceHeaderNotFound, fromHeader)
- }
- return setHeaderOverrideInContext(context, toHeader, value, keepOrigin)
- }
-
- func moveHeaderInContext(context map[string]interface{}, fromHeader, toHeader string, keepOrigin bool) error {
- fromHeader = normalizeHeaderContextKey(fromHeader)
- toHeader = normalizeHeaderContextKey(toHeader)
- if fromHeader == "" || toHeader == "" {
- return fmt.Errorf("move_header from/to is required")
- }
- if err := copyHeaderInContext(context, fromHeader, toHeader, keepOrigin); err != nil {
- return err
- }
- if strings.EqualFold(fromHeader, toHeader) {
- return nil
- }
- return deleteHeaderOverrideInContext(context, fromHeader)
- }
-
- func deleteHeaderOverrideInContext(context map[string]interface{}, headerName string) error {
- headerName = normalizeHeaderContextKey(headerName)
- if headerName == "" {
- return fmt.Errorf("header name is required")
- }
- rawHeaders := ensureMapKeyInContext(context, paramOverrideContextHeaderOverride)
- delete(rawHeaders, headerName)
- return nil
- }
-
- func parseHeaderPassThroughNames(value interface{}) ([]string, error) {
- normalizeNames := func(values []string) []string {
- names := lo.FilterMap(values, func(item string, _ int) (string, bool) {
- headerName := normalizeHeaderContextKey(item)
- if headerName == "" {
- return "", false
- }
- return headerName, true
- })
- return lo.Uniq(names)
- }
-
- switch raw := value.(type) {
- case nil:
- return nil, fmt.Errorf("pass_headers value is required")
- case string:
- trimmed := strings.TrimSpace(raw)
- if trimmed == "" {
- return nil, fmt.Errorf("pass_headers value is required")
- }
- if strings.HasPrefix(trimmed, "[") || strings.HasPrefix(trimmed, "{") {
- var parsed interface{}
- if err := common.UnmarshalJsonStr(trimmed, &parsed); err == nil {
- return parseHeaderPassThroughNames(parsed)
- }
- }
- names := normalizeNames(strings.Split(trimmed, ","))
- if len(names) == 0 {
- return nil, fmt.Errorf("pass_headers value is invalid")
- }
- return names, nil
- case []interface{}:
- names := lo.FilterMap(raw, func(item interface{}, _ int) (string, bool) {
- headerName := normalizeHeaderContextKey(fmt.Sprintf("%v", item))
- if headerName == "" {
- return "", false
- }
- return headerName, true
- })
- names = lo.Uniq(names)
- if len(names) == 0 {
- return nil, fmt.Errorf("pass_headers value is invalid")
- }
- return names, nil
- case []string:
- names := lo.FilterMap(raw, func(item string, _ int) (string, bool) {
- headerName := normalizeHeaderContextKey(item)
- if headerName == "" {
- return "", false
- }
- return headerName, true
- })
- names = lo.Uniq(names)
- if len(names) == 0 {
- return nil, fmt.Errorf("pass_headers value is invalid")
- }
- return names, nil
- case map[string]interface{}:
- candidates := make([]string, 0, 8)
- if headersRaw, ok := raw["headers"]; ok {
- names, err := parseHeaderPassThroughNames(headersRaw)
- if err == nil {
- candidates = append(candidates, names...)
- }
- }
- if namesRaw, ok := raw["names"]; ok {
- names, err := parseHeaderPassThroughNames(namesRaw)
- if err == nil {
- candidates = append(candidates, names...)
- }
- }
- if headerRaw, ok := raw["header"]; ok {
- names, err := parseHeaderPassThroughNames(headerRaw)
- if err == nil {
- candidates = append(candidates, names...)
- }
- }
- names := normalizeNames(candidates)
- if len(names) == 0 {
- return nil, fmt.Errorf("pass_headers value is invalid")
- }
- return names, nil
- default:
- return nil, fmt.Errorf("pass_headers value must be string, array or object")
- }
- }
-
- type syncTarget struct {
- kind string
- key string
- }
-
- func parseSyncTarget(spec string) (syncTarget, error) {
- raw := strings.TrimSpace(spec)
- if raw == "" {
- return syncTarget{}, fmt.Errorf("sync_fields target is required")
- }
-
- idx := strings.Index(raw, ":")
- if idx < 0 {
- // Backward compatibility: treat bare value as JSON path.
- return syncTarget{
- kind: "json",
- key: raw,
- }, nil
- }
-
- kind := strings.ToLower(strings.TrimSpace(raw[:idx]))
- key := strings.TrimSpace(raw[idx+1:])
- if key == "" {
- return syncTarget{}, fmt.Errorf("sync_fields target key is required: %s", raw)
- }
-
- switch kind {
- case "json", "body":
- return syncTarget{
- kind: "json",
- key: key,
- }, nil
- case "header":
- return syncTarget{
- kind: "header",
- key: key,
- }, nil
- default:
- return syncTarget{}, fmt.Errorf("sync_fields target prefix is invalid: %s", raw)
- }
- }
-
- func readSyncTargetValue(jsonStr string, context map[string]interface{}, target syncTarget) (interface{}, bool, error) {
- switch target.kind {
- case "json":
- path := processNegativeIndex(jsonStr, target.key)
- value := gjson.Get(jsonStr, path)
- if !value.Exists() || value.Type == gjson.Null {
- return nil, false, nil
- }
- if value.Type == gjson.String && strings.TrimSpace(value.String()) == "" {
- return nil, false, nil
- }
- return value.Value(), true, nil
- case "header":
- value, ok := getHeaderValueFromContext(context, target.key)
- if !ok || strings.TrimSpace(value) == "" {
- return nil, false, nil
- }
- return value, true, nil
- default:
- return nil, false, fmt.Errorf("unsupported sync_fields target kind: %s", target.kind)
- }
- }
-
- func writeSyncTargetValue(jsonStr string, context map[string]interface{}, target syncTarget, value interface{}) (string, error) {
- switch target.kind {
- case "json":
- path := processNegativeIndex(jsonStr, target.key)
- nextJSON, err := sjson.Set(jsonStr, path, value)
- if err != nil {
- return "", err
- }
- return nextJSON, nil
- case "header":
- if err := setHeaderOverrideInContext(context, target.key, value, false); err != nil {
- return "", err
- }
- return jsonStr, nil
- default:
- return "", fmt.Errorf("unsupported sync_fields target kind: %s", target.kind)
- }
- }
-
- func syncFieldsBetweenTargets(jsonStr string, context map[string]interface{}, fromSpec string, toSpec string) (string, error) {
- fromTarget, err := parseSyncTarget(fromSpec)
- if err != nil {
- return "", err
- }
- toTarget, err := parseSyncTarget(toSpec)
- if err != nil {
- return "", err
- }
-
- fromValue, fromExists, err := readSyncTargetValue(jsonStr, context, fromTarget)
- if err != nil {
- return "", err
- }
- toValue, toExists, err := readSyncTargetValue(jsonStr, context, toTarget)
- if err != nil {
- return "", err
- }
-
- // If one side exists and the other side is missing, sync the missing side.
- if fromExists && !toExists {
- return writeSyncTargetValue(jsonStr, context, toTarget, fromValue)
- }
- if toExists && !fromExists {
- return writeSyncTargetValue(jsonStr, context, fromTarget, toValue)
- }
- return jsonStr, nil
- }
-
- func ensureMapKeyInContext(context map[string]interface{}, key string) map[string]interface{} {
- if context == nil {
- return map[string]interface{}{}
- }
- if existing, ok := context[key]; ok {
- if mapVal, ok := existing.(map[string]interface{}); ok {
- return mapVal
- }
- }
- result := make(map[string]interface{})
- context[key] = result
- return result
- }
-
- func getHeaderValueFromContext(context map[string]interface{}, headerName string) (string, bool) {
- headerName = normalizeHeaderContextKey(headerName)
- if headerName == "" {
- return "", false
- }
- for _, key := range []string{paramOverrideContextHeaderOverride, paramOverrideContextRequestHeaders} {
- source := ensureMapKeyInContext(context, key)
- raw, ok := source[headerName]
- if !ok {
- continue
- }
- value := strings.TrimSpace(fmt.Sprintf("%v", raw))
- if value != "" {
- return value, true
- }
- }
- return "", false
- }
-
- func normalizeHeaderContextKey(key string) string {
- return strings.TrimSpace(strings.ToLower(key))
- }
-
- func buildRequestHeadersContext(headers map[string]string) map[string]interface{} {
- if len(headers) == 0 {
- return map[string]interface{}{}
- }
- entries := lo.Entries(headers)
- normalizedEntries := lo.FilterMap(entries, func(item lo.Entry[string, string], _ int) (lo.Entry[string, string], bool) {
- normalized := normalizeHeaderContextKey(item.Key)
- value := strings.TrimSpace(item.Value)
- if normalized == "" || value == "" {
- return lo.Entry[string, string]{}, false
- }
- return lo.Entry[string, string]{Key: normalized, Value: value}, true
- })
- return lo.SliceToMap(normalizedEntries, func(item lo.Entry[string, string]) (string, interface{}) {
- return item.Key, item.Value
- })
- }
-
- func syncRuntimeHeaderOverrideFromContext(info *RelayInfo, context map[string]interface{}) {
- if info == nil || context == nil {
- return
- }
- raw, exists := context[paramOverrideContextHeaderOverride]
- if !exists {
- return
- }
- rawMap, ok := raw.(map[string]interface{})
- if !ok {
- return
- }
- info.RuntimeHeadersOverride = sanitizeHeaderOverrideMap(rawMap)
- info.UseRuntimeHeadersOverride = true
- }
-
- func moveValue(jsonStr, fromPath, toPath string) (string, error) {
- sourceValue := gjson.Get(jsonStr, fromPath)
- if !sourceValue.Exists() {
- return jsonStr, fmt.Errorf("source path does not exist: %s", fromPath)
- }
- result, err := sjson.Set(jsonStr, toPath, sourceValue.Value())
- if err != nil {
- return "", err
- }
- return sjson.Delete(result, fromPath)
- }
-
- func copyValue(jsonStr, fromPath, toPath string) (string, error) {
- sourceValue := gjson.Get(jsonStr, fromPath)
- if !sourceValue.Exists() {
- return jsonStr, fmt.Errorf("source path does not exist: %s", fromPath)
- }
- return sjson.Set(jsonStr, toPath, sourceValue.Value())
- }
-
- func isPathBasedOperation(mode string) bool {
- switch mode {
- case "delete", "set", "prepend", "append", "trim_prefix", "trim_suffix", "ensure_prefix", "ensure_suffix", "trim_space", "to_lower", "to_upper", "replace", "regex_replace", "prune_objects":
- return true
- default:
- return false
- }
- }
-
- func resolveOperationPaths(jsonStr, path string) ([]string, error) {
- if !strings.Contains(path, "*") {
- return []string{path}, nil
- }
- return expandWildcardPaths(jsonStr, path)
- }
-
- func expandWildcardPaths(jsonStr, path string) ([]string, error) {
- var root interface{}
- if err := common.Unmarshal([]byte(jsonStr), &root); err != nil {
- return nil, err
- }
-
- segments := strings.Split(path, ".")
- paths := collectWildcardPaths(root, segments, nil)
- return lo.Uniq(paths), nil
- }
-
- func collectWildcardPaths(node interface{}, segments []string, prefix []string) []string {
- if len(segments) == 0 {
- return []string{strings.Join(prefix, ".")}
- }
-
- segment := strings.TrimSpace(segments[0])
- if segment == "" {
- return nil
- }
- isLast := len(segments) == 1
-
- if segment == "*" {
- switch typed := node.(type) {
- case map[string]interface{}:
- keys := lo.Keys(typed)
- sort.Strings(keys)
- return lo.FlatMap(keys, func(key string, _ int) []string {
- return collectWildcardPaths(typed[key], segments[1:], append(prefix, key))
- })
- case []interface{}:
- return lo.FlatMap(lo.Range(len(typed)), func(index int, _ int) []string {
- return collectWildcardPaths(typed[index], segments[1:], append(prefix, strconv.Itoa(index)))
- })
- default:
- return nil
- }
- }
-
- switch typed := node.(type) {
- case map[string]interface{}:
- if isLast {
- return []string{strings.Join(append(prefix, segment), ".")}
- }
- next, exists := typed[segment]
- if !exists {
- return nil
- }
- return collectWildcardPaths(next, segments[1:], append(prefix, segment))
- case []interface{}:
- index, err := strconv.Atoi(segment)
- if err != nil || index < 0 || index >= len(typed) {
- return nil
- }
- if isLast {
- return []string{strings.Join(append(prefix, segment), ".")}
- }
- return collectWildcardPaths(typed[index], segments[1:], append(prefix, segment))
- default:
- return nil
- }
- }
-
- func deleteValue(jsonStr, path string) (string, error) {
- if strings.TrimSpace(path) == "" {
- return jsonStr, nil
- }
- return sjson.Delete(jsonStr, path)
- }
-
- func modifyValue(jsonStr, path string, value interface{}, keepOrigin, isPrepend bool) (string, error) {
- current := gjson.Get(jsonStr, path)
- switch {
- case current.IsArray():
- return modifyArray(jsonStr, path, value, isPrepend)
- case current.Type == gjson.String:
- return modifyString(jsonStr, path, value, isPrepend)
- case current.Type == gjson.JSON:
- return mergeObjects(jsonStr, path, value, keepOrigin)
- }
- return jsonStr, fmt.Errorf("operation not supported for type: %v", current.Type)
- }
-
- func modifyArray(jsonStr, path string, value interface{}, isPrepend bool) (string, error) {
- current := gjson.Get(jsonStr, path)
- var newArray []interface{}
- // 添加新值
- addValue := func() {
- if arr, ok := value.([]interface{}); ok {
- newArray = append(newArray, arr...)
- } else {
- newArray = append(newArray, value)
- }
- }
- // 添加原值
- addOriginal := func() {
- current.ForEach(func(_, val gjson.Result) bool {
- newArray = append(newArray, val.Value())
- return true
- })
- }
- if isPrepend {
- addValue()
- addOriginal()
- } else {
- addOriginal()
- addValue()
- }
- return sjson.Set(jsonStr, path, newArray)
- }
-
- func modifyString(jsonStr, path string, value interface{}, isPrepend bool) (string, error) {
- current := gjson.Get(jsonStr, path)
- valueStr := fmt.Sprintf("%v", value)
- var newStr string
- if isPrepend {
- newStr = valueStr + current.String()
- } else {
- newStr = current.String() + valueStr
- }
- return sjson.Set(jsonStr, path, newStr)
- }
-
- func trimStringValue(jsonStr, path string, value interface{}, isPrefix bool) (string, error) {
- current := gjson.Get(jsonStr, path)
- if current.Type != gjson.String {
- return jsonStr, fmt.Errorf("operation not supported for type: %v", current.Type)
- }
-
- if value == nil {
- return jsonStr, fmt.Errorf("trim value is required")
- }
- valueStr := fmt.Sprintf("%v", value)
-
- var newStr string
- if isPrefix {
- newStr = strings.TrimPrefix(current.String(), valueStr)
- } else {
- newStr = strings.TrimSuffix(current.String(), valueStr)
- }
- return sjson.Set(jsonStr, path, newStr)
- }
-
- func ensureStringAffix(jsonStr, path string, value interface{}, isPrefix bool) (string, error) {
- current := gjson.Get(jsonStr, path)
- if current.Type != gjson.String {
- return jsonStr, fmt.Errorf("operation not supported for type: %v", current.Type)
- }
-
- if value == nil {
- return jsonStr, fmt.Errorf("ensure value is required")
- }
- valueStr := fmt.Sprintf("%v", value)
- if valueStr == "" {
- return jsonStr, fmt.Errorf("ensure value is required")
- }
-
- currentStr := current.String()
- if isPrefix {
- if strings.HasPrefix(currentStr, valueStr) {
- return jsonStr, nil
- }
- return sjson.Set(jsonStr, path, valueStr+currentStr)
- }
-
- if strings.HasSuffix(currentStr, valueStr) {
- return jsonStr, nil
- }
- return sjson.Set(jsonStr, path, currentStr+valueStr)
- }
-
- func transformStringValue(jsonStr, path string, transform func(string) string) (string, error) {
- current := gjson.Get(jsonStr, path)
- if current.Type != gjson.String {
- return jsonStr, fmt.Errorf("operation not supported for type: %v", current.Type)
- }
- return sjson.Set(jsonStr, path, transform(current.String()))
- }
-
- func replaceStringValue(jsonStr, path, from, to string) (string, error) {
- current := gjson.Get(jsonStr, path)
- if current.Type != gjson.String {
- return jsonStr, fmt.Errorf("operation not supported for type: %v", current.Type)
- }
- if from == "" {
- return jsonStr, fmt.Errorf("replace from is required")
- }
- return sjson.Set(jsonStr, path, strings.ReplaceAll(current.String(), from, to))
- }
-
- func regexReplaceStringValue(jsonStr, path, pattern, replacement string) (string, error) {
- current := gjson.Get(jsonStr, path)
- if current.Type != gjson.String {
- return jsonStr, fmt.Errorf("operation not supported for type: %v", current.Type)
- }
- if pattern == "" {
- return jsonStr, fmt.Errorf("regex pattern is required")
- }
- re, err := regexp.Compile(pattern)
- if err != nil {
- return jsonStr, err
- }
- return sjson.Set(jsonStr, path, re.ReplaceAllString(current.String(), replacement))
- }
-
- type pruneObjectsOptions struct {
- conditions []ConditionOperation
- logic string
- recursive bool
- }
-
- func pruneObjects(jsonStr, path, contextJSON string, value interface{}) (string, error) {
- options, err := parsePruneObjectsOptions(value)
- if err != nil {
- return "", err
- }
-
- if path == "" {
- var root interface{}
- if err := common.Unmarshal([]byte(jsonStr), &root); err != nil {
- return "", err
- }
- cleaned, _, err := pruneObjectsNode(root, options, contextJSON, true)
- if err != nil {
- return "", err
- }
- cleanedBytes, err := common.Marshal(cleaned)
- if err != nil {
- return "", err
- }
- return string(cleanedBytes), nil
- }
-
- target := gjson.Get(jsonStr, path)
- if !target.Exists() {
- return jsonStr, nil
- }
-
- var targetNode interface{}
- if target.Type == gjson.JSON {
- if err := common.Unmarshal([]byte(target.Raw), &targetNode); err != nil {
- return "", err
- }
- } else {
- targetNode = target.Value()
- }
-
- cleaned, _, err := pruneObjectsNode(targetNode, options, contextJSON, true)
- if err != nil {
- return "", err
- }
- cleanedBytes, err := common.Marshal(cleaned)
- if err != nil {
- return "", err
- }
- return sjson.SetRaw(jsonStr, path, string(cleanedBytes))
- }
-
- func parsePruneObjectsOptions(value interface{}) (pruneObjectsOptions, error) {
- opts := pruneObjectsOptions{
- logic: "AND",
- recursive: true,
- }
-
- switch raw := value.(type) {
- case nil:
- return opts, fmt.Errorf("prune_objects value is required")
- case string:
- v := strings.TrimSpace(raw)
- if v == "" {
- return opts, fmt.Errorf("prune_objects value is required")
- }
- opts.conditions = []ConditionOperation{
- {
- Path: "type",
- Mode: "full",
- Value: v,
- },
- }
- case map[string]interface{}:
- if logic, ok := raw["logic"].(string); ok && strings.TrimSpace(logic) != "" {
- opts.logic = logic
- }
- if recursive, ok := raw["recursive"].(bool); ok {
- opts.recursive = recursive
- }
-
- if condRaw, exists := raw["conditions"]; exists {
- conditions, err := parseConditionOperations(condRaw)
- if err != nil {
- return opts, err
- }
- opts.conditions = append(opts.conditions, conditions...)
- }
-
- if whereRaw, exists := raw["where"]; exists {
- whereMap, ok := whereRaw.(map[string]interface{})
- if !ok {
- return opts, fmt.Errorf("prune_objects where must be object")
- }
- for key, val := range whereMap {
- key = strings.TrimSpace(key)
- if key == "" {
- continue
- }
- opts.conditions = append(opts.conditions, ConditionOperation{
- Path: key,
- Mode: "full",
- Value: val,
- })
- }
- }
-
- if matchType, exists := raw["type"]; exists {
- opts.conditions = append(opts.conditions, ConditionOperation{
- Path: "type",
- Mode: "full",
- Value: matchType,
- })
- }
- default:
- return opts, fmt.Errorf("prune_objects value must be string or object")
- }
-
- if len(opts.conditions) == 0 {
- return opts, fmt.Errorf("prune_objects conditions are required")
- }
- return opts, nil
- }
-
- func parseConditionOperations(raw interface{}) ([]ConditionOperation, error) {
- switch typed := raw.(type) {
- case map[string]interface{}:
- entries := lo.Entries(typed)
- conditions := lo.FilterMap(entries, func(item lo.Entry[string, interface{}], _ int) (ConditionOperation, bool) {
- path := strings.TrimSpace(item.Key)
- if path == "" {
- return ConditionOperation{}, false
- }
- return ConditionOperation{
- Path: path,
- Mode: "full",
- Value: item.Value,
- }, true
- })
- if len(conditions) == 0 {
- return nil, fmt.Errorf("conditions object must contain at least one key")
- }
- return conditions, nil
- case []interface{}:
- items := typed
- result := make([]ConditionOperation, 0, len(items))
- for _, item := range items {
- itemMap, ok := item.(map[string]interface{})
- if !ok {
- return nil, fmt.Errorf("condition must be object")
- }
- path, _ := itemMap["path"].(string)
- mode, _ := itemMap["mode"].(string)
- if strings.TrimSpace(path) == "" || strings.TrimSpace(mode) == "" {
- return nil, fmt.Errorf("condition path/mode is required")
- }
- condition := ConditionOperation{
- Path: path,
- Mode: mode,
- }
- if value, exists := itemMap["value"]; exists {
- condition.Value = value
- }
- if invert, ok := itemMap["invert"].(bool); ok {
- condition.Invert = invert
- }
- if passMissingKey, ok := itemMap["pass_missing_key"].(bool); ok {
- condition.PassMissingKey = passMissingKey
- }
- result = append(result, condition)
- }
- return result, nil
- default:
- return nil, fmt.Errorf("conditions must be an array or object")
- }
- }
-
- func pruneObjectsNode(node interface{}, options pruneObjectsOptions, contextJSON string, isRoot bool) (interface{}, bool, error) {
- switch value := node.(type) {
- case []interface{}:
- result := make([]interface{}, 0, len(value))
- for _, item := range value {
- next, drop, err := pruneObjectsNode(item, options, contextJSON, false)
- if err != nil {
- return nil, false, err
- }
- if drop {
- continue
- }
- result = append(result, next)
- }
- return result, false, nil
- case map[string]interface{}:
- shouldDrop, err := shouldPruneObject(value, options, contextJSON)
- if err != nil {
- return nil, false, err
- }
- if shouldDrop && !isRoot {
- return nil, true, nil
- }
- if !options.recursive {
- return value, false, nil
- }
- for key, child := range value {
- next, drop, err := pruneObjectsNode(child, options, contextJSON, false)
- if err != nil {
- return nil, false, err
- }
- if drop {
- delete(value, key)
- continue
- }
- value[key] = next
- }
- return value, false, nil
- default:
- return node, false, nil
- }
- }
-
- func shouldPruneObject(node map[string]interface{}, options pruneObjectsOptions, contextJSON string) (bool, error) {
- nodeBytes, err := common.Marshal(node)
- if err != nil {
- return false, err
- }
- return checkConditions(string(nodeBytes), contextJSON, options.conditions, options.logic)
- }
-
- func mergeObjects(jsonStr, path string, value interface{}, keepOrigin bool) (string, error) {
- current := gjson.Get(jsonStr, path)
- var currentMap, newMap map[string]interface{}
-
- // 解析当前值
- if err := common.Unmarshal([]byte(current.Raw), ¤tMap); err != nil {
- return "", err
- }
- // 解析新值
- switch v := value.(type) {
- case map[string]interface{}:
- newMap = v
- default:
- jsonBytes, _ := common.Marshal(v)
- if err := common.Unmarshal(jsonBytes, &newMap); err != nil {
- return "", err
- }
- }
- // 合并
- result := make(map[string]interface{})
- for k, v := range currentMap {
- result[k] = v
- }
- for k, v := range newMap {
- if !keepOrigin || result[k] == nil {
- result[k] = v
- }
- }
- return sjson.Set(jsonStr, path, result)
- }
-
- // BuildParamOverrideContext 提供 ApplyParamOverride 可用的上下文信息。
- // 目前内置以下字段:
- // - upstream_model/model:始终为通道映射后的上游模型名。
- // - original_model:请求最初指定的模型名。
- // - request_path:请求路径
- // - is_channel_test:是否为渠道测试请求(同 is_test)。
- func BuildParamOverrideContext(info *RelayInfo) map[string]interface{} {
- if info == nil {
- return nil
- }
-
- ctx := make(map[string]interface{})
- if info.ChannelMeta != nil && info.ChannelMeta.UpstreamModelName != "" {
- ctx["model"] = info.ChannelMeta.UpstreamModelName
- ctx["upstream_model"] = info.ChannelMeta.UpstreamModelName
- }
- if info.OriginModelName != "" {
- ctx["original_model"] = info.OriginModelName
- if _, exists := ctx["model"]; !exists {
- ctx["model"] = info.OriginModelName
- }
- }
-
- if info.RequestURLPath != "" {
- requestPath := info.RequestURLPath
- if requestPath != "" {
- ctx["request_path"] = requestPath
- }
- }
-
- ctx[paramOverrideContextRequestHeaders] = buildRequestHeadersContext(info.RequestHeaders)
-
- headerOverrideSource := GetEffectiveHeaderOverride(info)
- ctx[paramOverrideContextHeaderOverride] = sanitizeHeaderOverrideMap(headerOverrideSource)
-
- ctx["retry_index"] = info.RetryIndex
- ctx["is_retry"] = info.RetryIndex > 0
- ctx["retry"] = map[string]interface{}{
- "index": info.RetryIndex,
- "is_retry": info.RetryIndex > 0,
- }
-
- if info.LastError != nil {
- code := string(info.LastError.GetErrorCode())
- errorType := string(info.LastError.GetErrorType())
- lastError := map[string]interface{}{
- "status_code": info.LastError.StatusCode,
- "message": info.LastError.Error(),
- "code": code,
- "error_code": code,
- "type": errorType,
- "error_type": errorType,
- "skip_retry": types.IsSkipRetryError(info.LastError),
- }
- ctx["last_error"] = lastError
- ctx["last_error_status_code"] = info.LastError.StatusCode
- ctx["last_error_message"] = info.LastError.Error()
- ctx["last_error_code"] = code
- ctx["last_error_type"] = errorType
- }
-
- ctx["is_channel_test"] = info.IsChannelTest
- return ctx
- }
|