feat: patch plugin (#346)

* feat: patch plugin init

* feat: condition logic and lazy patch support

* feat: gpt-5 temperature

* fix: claude to openai multi toolcall support

* fix: max completion tokens support in claude to openai

* feat: gemini adaptor support claude request

* fix: ci lint

* fix: go test fails

core/.golangci.yml

@@ -1,7 +1,7 @@
 version: "2"
 
 run:
-  go: "1.24"
+  go: "1.25.0"
   relative-path-mode: gomod
   modules-download-mode: readonly
 

core/controller/relay-controller.go

@@ -29,6 +29,7 @@ import (
 	"github.com/labring/aiproxy/core/relay/plugin"
 	"github.com/labring/aiproxy/core/relay/plugin/cache"
 	monitorplugin "github.com/labring/aiproxy/core/relay/plugin/monitor"
+	"github.com/labring/aiproxy/core/relay/plugin/patch"
 	"github.com/labring/aiproxy/core/relay/plugin/streamfake"
 	"github.com/labring/aiproxy/core/relay/plugin/thinksplit"
 	"github.com/labring/aiproxy/core/relay/plugin/timeout"
@@ -87,6 +88,7 @@ func wrapPlugin(ctx context.Context, mc *model.ModelCaches, a adaptor.Adaptor) a
 		monitorplugin.NewGroupMonitorPlugin(),
 		cache.NewCachePlugin(common.RDB),
 		streamfake.NewStreamFakePlugin(),
+		patch.NewPatchPlugin(),
 		timeout.NewTimeoutPlugin(),
 		websearch.NewWebSearchPlugin(func(modelName string) (*model.Channel, error) {
 			return getWebSearchChannel(ctx, mc, modelName)

core/relay/adaptor/gemini/adaptor.go

@@ -22,7 +22,9 @@ func (a *Adaptor) DefaultBaseURL() string {
 }
 
 func (a *Adaptor) SupportMode(m mode.Mode) bool {
-	return m == mode.ChatCompletions || m == mode.Embeddings
+	return m == mode.ChatCompletions ||
+		m == mode.Anthropic ||
+		m == mode.Embeddings
 }
 
 var v1ModelMap = map[string]struct{}{}
@@ -80,6 +82,8 @@ func (a *Adaptor) ConvertRequest(
 		return ConvertEmbeddingRequest(meta, req)
 	case mode.ChatCompletions:
 		return ConvertRequest(meta, req)
+	case mode.Anthropic:
+		return ConvertClaudeRequest(meta, req)
 	default:
 		return adaptor.ConvertResult{}, fmt.Errorf("unsupported mode: %s", meta.Mode)
 	}
@@ -109,6 +113,12 @@ func (a *Adaptor) DoResponse(
 		} else {
 			usage, err = Handler(meta, c, resp)
 		}
+	case mode.Anthropic:
+		if utils.IsStreamResponse(resp) {
+			usage, err = ClaudeStreamHandler(meta, c, resp)
+		} else {
+			usage, err = ClaudeHandler(meta, c, resp)
+		}
 	default:
 		return model.Usage{}, relaymodel.WrapperOpenAIErrorWithMessage(
 			fmt.Sprintf("unsupported mode: %s", meta.Mode),

core/relay/adaptor/gemini/claude.go

@@ -0,0 +1,442 @@
+package gemini
+
+import (
+	"bufio"
+	"bytes"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"github.com/bytedance/sonic"
+	"github.com/gin-gonic/gin"
+	"github.com/labring/aiproxy/core/common"
+	"github.com/labring/aiproxy/core/model"
+	"github.com/labring/aiproxy/core/relay/adaptor"
+	"github.com/labring/aiproxy/core/relay/adaptor/openai"
+	"github.com/labring/aiproxy/core/relay/meta"
+	relaymodel "github.com/labring/aiproxy/core/relay/model"
+	"github.com/labring/aiproxy/core/relay/render"
+	"github.com/labring/aiproxy/core/relay/utils"
+)
+
+func ConvertClaudeRequest(meta *meta.Meta, req *http.Request) (adaptor.ConvertResult, error) {
+	adaptorConfig := Config{}
+
+	err := meta.ChannelConfig.SpecConfig(&adaptorConfig)
+	if err != nil {
+		return adaptor.ConvertResult{}, err
+	}
+
+	textRequest, err := openai.ConvertClaudeRequestModel(meta, req)
+	if err != nil {
+		return adaptor.ConvertResult{}, err
+	}
+
+	textRequest.Model = meta.ActualModel
+	meta.Set("stream", textRequest.Stream)
+
+	systemContent, contents, imageTasks := buildContents(textRequest)
+
+	// Process image tasks concurrently
+	if len(imageTasks) > 0 {
+		if err := processImageTasks(req.Context(), imageTasks); err != nil {
+			return adaptor.ConvertResult{}, err
+		}
+	}
+
+	config := buildGenerationConfig(meta, textRequest, textRequest)
+
+	// Build actual request
+	geminiRequest := ChatRequest{
+		Contents:          contents,
+		SystemInstruction: systemContent,
+		SafetySettings:    buildSafetySettings(adaptorConfig.Safety),
+		GenerationConfig:  config,
+		Tools:             buildTools(textRequest),
+		ToolConfig:        buildToolConfig(textRequest),
+	}
+
+	data, err := sonic.Marshal(geminiRequest)
+	if err != nil {
+		return adaptor.ConvertResult{}, err
+	}
+
+	// fmt.Println(string(data))
+
+	return adaptor.ConvertResult{
+		Header: http.Header{
+			"Content-Type":   {"application/json"},
+			"Content-Length": {strconv.Itoa(len(data))},
+		},
+		Body: bytes.NewReader(data),
+	}, nil
+}
+
+// ClaudeHandler handles non-streaming Gemini responses and converts them to Claude format
+func ClaudeHandler(
+	meta *meta.Meta,
+	c *gin.Context,
+	resp *http.Response,
+) (model.Usage, adaptor.Error) {
+	if resp.StatusCode != http.StatusOK {
+		return model.Usage{}, openai.ErrorHanlder(resp)
+	}
+
+	defer resp.Body.Close()
+
+	var geminiResponse ChatResponse
+
+	err := sonic.ConfigDefault.NewDecoder(resp.Body).Decode(&geminiResponse)
+	if err != nil {
+		return model.Usage{}, relaymodel.WrapperAnthropicError(
+			err,
+			"unmarshal_response_body_failed",
+			http.StatusInternalServerError,
+		)
+	}
+
+	// Convert Gemini response to Claude response
+	claudeResponse := geminiResponse2Claude(meta, &geminiResponse)
+
+	jsonResponse, err := sonic.Marshal(claudeResponse)
+	if err != nil {
+		return claudeResponse.Usage.ToOpenAIUsage().
+				ToModelUsage(),
+			relaymodel.WrapperAnthropicError(
+				err,
+				"marshal_response_body_failed",
+				http.StatusInternalServerError,
+			)
+	}
+
+	c.Writer.Header().Set("Content-Type", "application/json")
+	c.Writer.Header().Set("Content-Length", strconv.Itoa(len(jsonResponse)))
+	_, _ = c.Writer.Write(jsonResponse)
+
+	return claudeResponse.Usage.ToOpenAIUsage().ToModelUsage(), nil
+}
+
+// ClaudeStreamHandler handles streaming Gemini responses and converts them to Claude format
+func ClaudeStreamHandler(
+	meta *meta.Meta,
+	c *gin.Context,
+	resp *http.Response,
+) (model.Usage, adaptor.Error) {
+	if resp.StatusCode != http.StatusOK {
+		return model.Usage{}, openai.ErrorHanlder(resp)
+	}
+
+	defer resp.Body.Close()
+
+	log := common.GetLogger(c)
+
+	scanner := bufio.NewScanner(resp.Body)
+	if strings.Contains(meta.ActualModel, "image") {
+		buf := GetImageScannerBuffer()
+		defer PutImageScannerBuffer(buf)
+
+		scanner.Buffer(*buf, cap(*buf))
+	} else {
+		buf := utils.GetScannerBuffer()
+		defer utils.PutScannerBuffer(buf)
+
+		scanner.Buffer(*buf, cap(*buf))
+	}
+
+	var (
+		messageID           = "msg_" + common.ShortUUID()
+		contentText         strings.Builder
+		thinkingText        strings.Builder
+		usage               relaymodel.ChatUsage
+		stopReason          string
+		currentContentIndex = -1
+		currentContentType  = ""
+		sentMessageStart    = false
+		toolCallsBuffer     = make(map[int]*relaymodel.ClaudeContent)
+	)
+
+	// Helper function to close current content block
+	closeCurrentBlock := func() {
+		if currentContentIndex >= 0 {
+			_ = render.ClaudeObjectData(c, relaymodel.ClaudeStreamResponse{
+				Type:  "content_block_stop",
+				Index: currentContentIndex,
+			})
+		}
+	}
+
+	for scanner.Scan() {
+		data := scanner.Bytes()
+		if !render.IsValidSSEData(data) {
+			continue
+		}
+
+		data = render.ExtractSSEData(data)
+		if render.IsSSEDone(data) {
+			break
+		}
+
+		var geminiResponse ChatResponse
+
+		err := sonic.Unmarshal(data, &geminiResponse)
+		if err != nil {
+			log.Error("error unmarshalling stream response: " + err.Error())
+			continue
+		}
+
+		// Send message_start event (only once)
+		if !sentMessageStart {
+			sentMessageStart = true
+
+			messageStartResp := relaymodel.ClaudeStreamResponse{
+				Type: "message_start",
+				Message: &relaymodel.ClaudeResponse{
+					ID:      messageID,
+					Type:    "message",
+					Role:    "assistant",
+					Model:   meta.ActualModel,
+					Content: []relaymodel.ClaudeContent{},
+				},
+			}
+
+			// Add initial usage if available
+			if geminiResponse.UsageMetadata != nil {
+				claudeUsage := geminiResponse.UsageMetadata.ToUsage().ToClaudeUsage()
+				messageStartResp.Message.Usage = claudeUsage
+			}
+
+			_ = render.ClaudeObjectData(c, messageStartResp)
+
+			// Send ping event
+			_ = render.ClaudeObjectData(c, relaymodel.ClaudeStreamResponse{Type: "ping"})
+		}
+
+		// Update usage if available
+		if geminiResponse.UsageMetadata != nil {
+			usage = geminiResponse.UsageMetadata.ToUsage()
+		}
+
+		// Process each candidate
+		for _, candidate := range geminiResponse.Candidates {
+			// Handle finish reason
+			if candidate.FinishReason != "" {
+				stopReason = geminiFinishReason2Claude(candidate.FinishReason)
+			}
+
+			// Process content parts
+			for _, part := range candidate.Content.Parts {
+				switch {
+				case part.Thought:
+					// Handle thinking content
+					if currentContentType != "thinking" {
+						closeCurrentBlock()
+
+						currentContentIndex++
+						currentContentType = "thinking"
+
+						_ = render.ClaudeObjectData(c, relaymodel.ClaudeStreamResponse{
+							Type:  "content_block_start",
+							Index: currentContentIndex,
+							ContentBlock: &relaymodel.ClaudeContent{
+								Type:     "thinking",
+								Thinking: "",
+							},
+						})
+					}
+
+					thinkingText.WriteString(part.Text)
+
+					_ = render.ClaudeObjectData(c, relaymodel.ClaudeStreamResponse{
+						Type:  "content_block_delta",
+						Index: currentContentIndex,
+						Delta: &relaymodel.ClaudeDelta{
+							Type:     "thinking_delta",
+							Thinking: part.Text,
+						},
+					})
+				case part.Text != "":
+					// Handle text content
+					if currentContentType != "text" {
+						closeCurrentBlock()
+
+						currentContentIndex++
+						currentContentType = "text"
+
+						_ = render.ClaudeObjectData(c, relaymodel.ClaudeStreamResponse{
+							Type:  "content_block_start",
+							Index: currentContentIndex,
+							ContentBlock: &relaymodel.ClaudeContent{
+								Type: "text",
+								Text: "",
+							},
+						})
+					}
+
+					contentText.WriteString(part.Text)
+
+					_ = render.ClaudeObjectData(c, relaymodel.ClaudeStreamResponse{
+						Type:  "content_block_delta",
+						Index: currentContentIndex,
+						Delta: &relaymodel.ClaudeDelta{
+							Type: "text_delta",
+							Text: part.Text,
+						},
+					})
+				case part.FunctionCall != nil:
+					// Handle tool/function calls
+					closeCurrentBlock()
+
+					currentContentIndex++
+					currentContentType = "tool_use"
+
+					toolContent := &relaymodel.ClaudeContent{
+						Type:  "tool_use",
+						ID:    openai.CallID(),
+						Name:  part.FunctionCall.Name,
+						Input: part.FunctionCall.Args,
+					}
+					toolCallsBuffer[currentContentIndex] = toolContent
+
+					// Send content_block_start for tool use
+					_ = render.ClaudeObjectData(c, relaymodel.ClaudeStreamResponse{
+						Type:         "content_block_start",
+						Index:        currentContentIndex,
+						ContentBlock: toolContent,
+					})
+
+					// Send tool arguments as delta
+					args, _ := sonic.MarshalString(part.FunctionCall.Args)
+					_ = render.ClaudeObjectData(c, relaymodel.ClaudeStreamResponse{
+						Type:  "content_block_delta",
+						Index: currentContentIndex,
+						Delta: &relaymodel.ClaudeDelta{
+							Type:        "input_json_delta",
+							PartialJSON: args,
+						},
+					})
+				}
+			}
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		log.Error("error reading stream: " + err.Error())
+	}
+
+	// Close the last open content block
+	closeCurrentBlock()
+
+	// Calculate final usage if not provided
+	if usage.TotalTokens == 0 && (contentText.Len() > 0 || thinkingText.Len() > 0) {
+		totalText := contentText.String()
+		if thinkingText.Len() > 0 {
+			totalText = thinkingText.String() + "\n" + totalText
+		}
+
+		usage = openai.ResponseText2Usage(
+			totalText,
+			meta.ActualModel,
+			int64(meta.RequestUsage.InputTokens),
+		)
+	}
+
+	claudeUsage := usage.ToClaudeUsage()
+
+	if stopReason == "" {
+		stopReason = "end_turn"
+	}
+
+	// Send message_delta with final usage
+	_ = render.ClaudeObjectData(c, relaymodel.ClaudeStreamResponse{
+		Type: "message_delta",
+		Delta: &relaymodel.ClaudeDelta{
+			StopReason: &stopReason,
+		},
+		Usage: &claudeUsage,
+	})
+
+	// Send message_stop
+	_ = render.ClaudeObjectData(c, relaymodel.ClaudeStreamResponse{
+		Type: "message_stop",
+	})
+
+	return usage.ToModelUsage(), nil
+}
+
+// geminiResponse2Claude converts a Gemini response to Claude format
+func geminiResponse2Claude(meta *meta.Meta, response *ChatResponse) *relaymodel.ClaudeResponse {
+	claudeResponse := relaymodel.ClaudeResponse{
+		ID:           "msg_" + common.ShortUUID(),
+		Type:         "message",
+		Role:         "assistant",
+		Model:        meta.OriginModel,
+		Content:      []relaymodel.ClaudeContent{},
+		StopReason:   "",
+		StopSequence: nil,
+	}
+
+	// Convert usage
+	if response.UsageMetadata != nil {
+		usage := response.UsageMetadata.ToUsage()
+		claudeResponse.Usage = usage.ToClaudeUsage()
+	}
+
+	// Convert content from candidates
+	for _, candidate := range response.Candidates {
+		// Map finish reason
+		claudeResponse.StopReason = geminiFinishReason2Claude(candidate.FinishReason)
+
+		// Extract content
+		for _, part := range candidate.Content.Parts {
+			if part.FunctionCall != nil {
+				// Convert function call to tool use
+				claudeResponse.Content = append(claudeResponse.Content, relaymodel.ClaudeContent{
+					Type:  "tool_use",
+					ID:    openai.CallID(),
+					Name:  part.FunctionCall.Name,
+					Input: part.FunctionCall.Args,
+				})
+			} else if part.Text != "" {
+				if part.Thought {
+					// Add thinking content
+					claudeResponse.Content = append(claudeResponse.Content, relaymodel.ClaudeContent{
+						Type:     "thinking",
+						Thinking: part.Text,
+					})
+				} else {
+					// Add text content
+					claudeResponse.Content = append(claudeResponse.Content, relaymodel.ClaudeContent{
+						Type: "text",
+						Text: part.Text,
+					})
+				}
+			}
+		}
+	}
+
+	// If no content was added, ensure at least an empty text block
+	if len(claudeResponse.Content) == 0 {
+		claudeResponse.Content = append(claudeResponse.Content, relaymodel.ClaudeContent{
+			Type: "text",
+			Text: "",
+		})
+	}
+
+	return &claudeResponse
+}
+
+// geminiFinishReason2Claude converts Gemini finish reason to Claude stop reason
+func geminiFinishReason2Claude(reason string) string {
+	switch reason {
+	case "STOP":
+		return "end_turn"
+	case "MAX_TOKENS":
+		return "max_tokens"
+	case "TOOL_CALLS", "FUNCTION_CALL":
+		return "tool_use"
+	case "CONTENT_FILTER":
+		return "stop_sequence"
+	default:
+		return "end_turn"
+	}
+}

core/relay/adaptor/gemini/main.go

@@ -236,23 +236,31 @@ func buildMessageParts(message relaymodel.MessageContent) *Part {
 	return part
 }
 
+// Add this helper function to track tool calls
 func buildContents(
 	textRequest *relaymodel.GeneralOpenAIRequest,
 ) (*ChatContent, []*ChatContent, []*Part) {
 	contents := make([]*ChatContent, 0, len(textRequest.Messages))
 
-	var imageTasks []*Part
+	var (
+		imageTasks    []*Part
+		systemContent *ChatContent
+	)
 
-	var systemContent *ChatContent
+	// Track tool calls by ID to get their names for tool results
+	toolCallMap := make(map[string]string) // tool_call_id -> tool_name
 
 	for _, message := range textRequest.Messages {
 		content := ChatContent{
 			Role: message.Role,
 		}
 
+		// Track tool calls from assistant messages
 		switch {
 		case message.Role == "assistant" && len(message.ToolCalls) > 0:
 			for _, toolCall := range message.ToolCalls {
+				toolCallMap[toolCall.ID] = toolCall.Function.Name
+
 				var args map[string]any
 				if toolCall.Function.Arguments != "" {
 					if err := sonic.UnmarshalString(toolCall.Function.Arguments, &args); err != nil {
@@ -270,6 +278,18 @@ func buildContents(
 				})
 			}
 		case message.Role == "tool" && message.ToolCallID != "":
+			// Handle tool results - get the tool name from our map
+			toolName := toolCallMap[message.ToolCallID]
+			if toolName == "" {
+				// Fallback: try to get from message.Name if available
+				if message.Name != nil {
+					toolName = *message.Name
+				} else {
+					// If still no name, use a default or the tool ID
+					toolName = "tool_" + message.ToolCallID
+				}
+			}
+
 			var contentMap map[string]any
 			if message.Content != nil {
 				switch content := message.Content.(type) {
@@ -277,53 +297,58 @@ func buildContents(
 					contentMap = content
 				case string:
 					if err := sonic.UnmarshalString(content, &contentMap); err != nil {
-						log.Error("unmarshal content failed: " + err.Error())
+						contentMap = map[string]any{"result": content}
 					}
 				}
 			} else {
 				contentMap = make(map[string]any)
 			}
 
-			name := ""
-			if message.Name != nil {
-				name = *message.Name
-			}
-
 			content.Parts = append(content.Parts, &Part{
 				FunctionResponse: &FunctionResponse{
-					Name: name,
+					Name: toolName, // Now properly set
 					Response: struct {
 						Name    string         `json:"name"`
 						Content map[string]any `json:"content"`
 					}{
-						Name:    name,
+						Name:    toolName, // Now properly set
 						Content: contentMap,
 					},
 				},
 			})
+		case message.Role == "system":
+			systemContent = &ChatContent{
+				Role: "user", // Gemini uses "user" for system content
+				Parts: []*Part{{
+					Text: message.StringContent(),
+				}},
+			}
+
+			continue
 		default:
+			// Handle regular messages
 			openaiContent := message.ParseContent()
 			for _, part := range openaiContent {
-				part := buildMessageParts(part)
-				if part.InlineData != nil {
-					imageTasks = append(imageTasks, part)
+				msgPart := buildMessageParts(part)
+				if msgPart.InlineData != nil {
+					imageTasks = append(imageTasks, msgPart)
 				}
 
-				content.Parts = append(content.Parts, part)
+				content.Parts = append(content.Parts, msgPart)
 			}
 		}
 
+		// Adjust role for Gemini
 		switch content.Role {
 		case "assistant":
 			content.Role = "model"
 		case "tool":
 			content.Role = "user"
-		case "system":
-			systemContent = &content
-			continue
 		}
 
-		contents = append(contents, &content)
+		if len(content.Parts) > 0 {
+			contents = append(contents, &content)
+		}
 	}
 
 	return systemContent, contents, imageTasks

core/relay/adaptor/openai/claude.go

@@ -24,21 +24,46 @@ func ConvertClaudeRequest(
 	meta *meta.Meta,
 	req *http.Request,
 ) (adaptor.ConvertResult, error) {
+	openAIRequest, err := ConvertClaudeRequestModel(meta, req)
+	if err != nil {
+		return adaptor.ConvertResult{}, err
+	}
+
+	// Marshal the converted request
+	jsonData, err := sonic.Marshal(openAIRequest)
+	if err != nil {
+		return adaptor.ConvertResult{}, err
+	}
+
+	return adaptor.ConvertResult{
+		Header: http.Header{
+			"Content-Type":   {"application/json"},
+			"Content-Length": {strconv.Itoa(len(jsonData))},
+		},
+		Body: bytes.NewReader(jsonData),
+	}, nil
+}
+
+func ConvertClaudeRequestModel(
+	meta *meta.Meta,
+	req *http.Request,
+) (*relaymodel.GeneralOpenAIRequest, error) {
 	// Parse Claude request
 	var claudeRequest relaymodel.ClaudeAnyContentRequest
 
 	err := common.UnmarshalRequestReusable(req, &claudeRequest)
 	if err != nil {
-		return adaptor.ConvertResult{}, err
+		return nil, err
 	}
 
 	// Convert to OpenAI format
 	openAIRequest := relaymodel.GeneralOpenAIRequest{
-		Model:       meta.ActualModel,
-		Stream:      claudeRequest.Stream,
-		MaxTokens:   claudeRequest.MaxTokens,
-		Temperature: claudeRequest.Temperature,
-		TopP:        claudeRequest.TopP,
+		Model:               meta.ActualModel,
+		Stream:              claudeRequest.Stream,
+		MaxTokens:           claudeRequest.MaxTokens,
+		MaxCompletionTokens: claudeRequest.MaxCompletionTokens,
+		Temperature:         claudeRequest.Temperature,
+		TopP:                claudeRequest.TopP,
 	}
 
 	// Convert messages
@@ -62,19 +87,7 @@ func ConvertClaudeRequest(
 		}
 	}
 
-	// Marshal the converted request
-	jsonData, err := sonic.Marshal(openAIRequest)
-	if err != nil {
-		return adaptor.ConvertResult{}, err
-	}
-
-	return adaptor.ConvertResult{
-		Header: http.Header{
-			"Content-Type":   {"application/json"},
-			"Content-Length": {strconv.Itoa(len(jsonData))},
-		},
-		Body: bytes.NewReader(jsonData),
-	}, nil
+	return &openAIRequest, nil
 }
 
 // convertClaudeMessagesToOpenAI converts Claude message format to OpenAI format
@@ -106,22 +119,71 @@ func convertClaudeMessagesToOpenAI(
 
 	// Convert regular messages
 	for _, msg := range claudeRequest.Messages {
+		// Check if this is a user message with tool results - handle specially
+		if msg.Role == "user" {
+			content, ok := msg.Content.([]any)
+
+			hasToolResults := false
+			if ok {
+				rawBytes, _ := sonic.Marshal(content)
+
+				var contentArray []relaymodel.ClaudeContent
+
+				_ = sonic.Unmarshal(rawBytes, &contentArray)
+
+				// First check if there are any tool_result blocks
+				var regularContent []relaymodel.MessageContent
+				for _, content := range contentArray {
+					switch content.Type {
+					case "tool_result":
+						hasToolResults = true
+						// Create a separate tool message for each tool_result
+						toolMsg := relaymodel.Message{
+							Role:       "tool",
+							Content:    content.Content,
+							ToolCallID: content.ToolUseID,
+						}
+						messages = append(messages, toolMsg)
+					case "text":
+						// Collect non-tool_result content
+						regularContent = append(regularContent, relaymodel.MessageContent{
+							Type: relaymodel.ContentTypeText,
+							Text: content.Text,
+						})
+					}
+				}
+
+				// If there were tool results and also regular content, add the regular content as a user message
+				if hasToolResults {
+					if len(regularContent) > 0 {
+						messages = append(messages, relaymodel.Message{
+							Role:    "user",
+							Content: regularContent,
+						})
+					}
+
+					continue // Skip the normal message processing
+				}
+			}
+		}
+
+		// Regular message processing
 		openAIMsg := relaymodel.Message{
 			Role: msg.Role,
 		}
 
-		switch msg.Content.(type) {
+		switch content := msg.Content.(type) {
 		case string:
-			openAIMsg.Content = msg.Content
+			openAIMsg.Content = content
 		case []any:
-			rawBytes, _ := sonic.Marshal(msg.Content)
+			rawBytes, _ := sonic.Marshal(content)
 
-			var content []relaymodel.ClaudeContent
+			var contentArray []relaymodel.ClaudeContent
 
-			_ = sonic.Unmarshal(rawBytes, &content)
+			_ = sonic.Unmarshal(rawBytes, &contentArray)
 
 			var parts []relaymodel.MessageContent
-			for _, content := range content {
+			for _, content := range contentArray {
 				switch content.Type {
 				case "text":
 					parts = append(parts, relaymodel.MessageContent{
@@ -149,13 +211,8 @@ func convertClaudeMessagesToOpenAI(
 							ImageURL: &imageURL,
 						})
 					}
-				case "tool_result":
-					// Convert tool result to assistant message with tool calls
-					openAIMsg.Role = "tool"
-					openAIMsg.Content = content.Content
-					openAIMsg.ToolCallID = content.ToolUseID
 				case "tool_use":
-					// This should be handled as tool calls
+					// Handle tool calls
 					if openAIMsg.ToolCalls == nil {
 						openAIMsg.ToolCalls = []relaymodel.ToolCall{}
 					}
@@ -179,8 +236,6 @@ func convertClaudeMessagesToOpenAI(
 			}
 		}
 
-		// Handle different content types
-
 		messages = append(messages, openAIMsg)
 	}
 

core/relay/meta/meta.go

@@ -225,6 +225,35 @@ func (m *Meta) GetInt(key string) int {
 	return i
 }
 
+// PushToSlice appends an item to a slice stored under the given key
+func (m *Meta) PushToSlice(key string, item any) {
+	var slice []any
+	if existing, ok := m.Get(key); ok {
+		if existingSlice, ok := existing.([]any); ok {
+			slice = existingSlice
+		}
+	}
+
+	slice = append(slice, item)
+	m.Set(key, slice)
+}
+
+// GetSlice retrieves a slice stored under the given key
+func (m *Meta) GetSlice(key string) []any {
+	if slice, ok := m.Get(key); ok {
+		if typedSlice, ok := slice.([]any); ok {
+			return typedSlice
+		}
+	}
+
+	return nil
+}
+
+// ClearSlice removes the slice stored under the given key
+func (m *Meta) ClearSlice(key string) {
+	m.Delete(key)
+}
+
 func GetMappedModelName(modelName string, mapping map[string]string) (string, bool) {
 	if len(modelName) == 0 {
 		return modelName, false

core/relay/model/claude.go

@@ -146,18 +146,19 @@ type ClaudeRequest struct {
 }
 
 type ClaudeAnyContentRequest struct {
-	ToolChoice    any                       `json:"tool_choice,omitempty"`
-	Temperature   *float64                  `json:"temperature,omitempty"`
-	TopP          *float64                  `json:"top_p,omitempty"`
-	Model         string                    `json:"model,omitempty"`
-	System        []ClaudeContent           `json:"system,omitempty"`
-	Messages      []ClaudeAnyContentMessage `json:"messages"`
-	StopSequences []string                  `json:"stop_sequences,omitempty"`
-	Tools         []ClaudeTool              `json:"tools,omitempty"`
-	MaxTokens     int                       `json:"max_tokens,omitempty"`
-	TopK          int                       `json:"top_k,omitempty"`
-	Stream        bool                      `json:"stream,omitempty"`
-	Thinking      *ClaudeThinking           `json:"thinking,omitempty"`
+	ToolChoice          any                       `json:"tool_choice,omitempty"`
+	Temperature         *float64                  `json:"temperature,omitempty"`
+	TopP                *float64                  `json:"top_p,omitempty"`
+	Model               string                    `json:"model,omitempty"`
+	System              []ClaudeContent           `json:"system,omitempty"`
+	Messages            []ClaudeAnyContentMessage `json:"messages"`
+	StopSequences       []string                  `json:"stop_sequences,omitempty"`
+	Tools               []ClaudeTool              `json:"tools,omitempty"`
+	MaxTokens           int                       `json:"max_tokens,omitempty"`
+	MaxCompletionTokens int                       `json:"max_completion_tokens,omitempty"`
+	TopK                int                       `json:"top_k,omitempty"`
+	Stream              bool                      `json:"stream,omitempty"`
+	Thinking            *ClaudeThinking           `json:"thinking,omitempty"`
 }
 
 type ClaudeUsage struct {

core/relay/model/completions.go

@@ -1,6 +1,8 @@
 package model
 
-import "strings"
+import (
+	"strings"
+)
 
 type ResponseFormat struct {
 	JSONSchema *JSONSchema `json:"json_schema,omitempty"`
@@ -32,7 +34,6 @@ type GeneralOpenAIRequest struct {
 	FunctionCall        any             `json:"function_call,omitempty"`
 	ToolChoice          any             `json:"tool_choice,omitempty"`
 	Stop                any             `json:"stop,omitempty"`
-	MaxCompletionTokens *int            `json:"max_completion_tokens,omitempty"`
 	TopLogprobs         *int            `json:"top_logprobs,omitempty"`
 	PresencePenalty     *float64        `json:"presence_penalty,omitempty"`
 	ResponseFormat      *ResponseFormat `json:"response_format,omitempty"`
@@ -48,6 +49,7 @@ type GeneralOpenAIRequest struct {
 	Tools               []Tool          `json:"tools,omitempty"`
 	Seed                float64         `json:"seed,omitempty"`
 	MaxTokens           int             `json:"max_tokens,omitempty"`
+	MaxCompletionTokens int             `json:"max_completion_tokens,omitempty"`
 	TopK                int             `json:"top_k,omitempty"`
 	NumCtx              int             `json:"num_ctx,omitempty"`
 	Stream              bool            `json:"stream,omitempty"`
@@ -172,19 +174,16 @@ func (m *Message) StringContent() string {
 func (m *Message) ParseContent() []MessageContent {
 	var contentList []MessageContent
 
-	content, ok := m.Content.(string)
-	if ok {
+	switch content := m.Content.(type) {
+	case string:
 		contentList = append(contentList, MessageContent{
 			Type: ContentTypeText,
 			Text: content,
 		})
 
 		return contentList
-	}
-
-	anyList, ok := m.Content.([]any)
-	if ok {
-		for _, contentItem := range anyList {
+	case []any:
+		for _, contentItem := range content {
 			contentMap, ok := contentItem.(map[string]any)
 			if !ok {
 				continue
@@ -216,9 +215,33 @@ func (m *Message) ParseContent() []MessageContent {
 		}
 
 		return contentList
-	}
+	case []MessageContent:
+		for _, contentItem := range content {
+			switch contentItem.Type {
+			case ContentTypeText:
+				contentList = append(contentList, MessageContent{
+					Type: ContentTypeText,
+					Text: contentItem.Text,
+				})
+			case ContentTypeImageURL:
+				imageURL := contentItem.ImageURL
+				if imageURL == nil {
+					continue
+				}
+
+				contentList = append(contentList, MessageContent{
+					Type: ContentTypeImageURL,
+					ImageURL: &ImageURL{
+						URL: imageURL.URL,
+					},
+				})
+			}
+		}
 
-	return nil
+		return contentList
+	default:
+		return nil
+	}
 }
 
 type ImageURL struct {

core/relay/plugin/patch/README.md

@@ -0,0 +1,253 @@
+# Patch Plugin
+
+The Patch Plugin provides powerful JSON request modification capabilities using sonic for high-performance JSON processing. It allows you to automatically modify API requests based on model types, field values, or custom conditions.
+
+## Features
+
+- **High Performance**: Uses ByteDance's sonic library for fast JSON parsing and manipulation
+- **Predefined Patches**: Built-in patches for common scenarios (DeepSeek max_tokens limits, GPT-5 compatibility, etc.)
+- **User-Defined Patches**: Flexible configuration system for custom patches
+- **Conditional Logic**: Apply patches based on model types, field values, or complex conditions
+- **Multiple Operations**: Set, delete, add, and limit operations on JSON fields
+- **Nested Field Support**: Use dot notation to modify nested JSON structures
+- **Placeholder Support**: Dynamic value replacement using `{{field_name}}` syntax
+
+## Predefined Patches
+
+The plugin comes with several built-in patches:
+
+### 1. DeepSeek Max Tokens Limit
+- **Purpose**: Limits `max_tokens` to 16000 for DeepSeek models
+- **Condition**: Model name contains "deepseek"
+- **Operation**: Limits `max_tokens` field to maximum 16000
+
+### 2. GPT-5 Max Tokens Conversion
+- **Purpose**: Converts `max_tokens` to `max_completion_tokens` for GPT-5 models
+- **Condition**: Model name contains "gpt-5" and `max_tokens` field exists
+- **Operation**: 
+  - Sets `max_completion_tokens` to the value of `max_tokens`
+  - Removes the `max_tokens` field
+
+### 3. O1 Models Max Tokens Conversion
+- **Purpose**: Converts `max_tokens` to `max_completion_tokens` for o1 models
+- **Condition**: Model matches o1, o1-preview, or o1-mini
+- **Operation**: Same as GPT-5 conversion
+
+### 4. Claude Max Tokens Limit
+- **Purpose**: Limits `max_tokens` to 8192 for Claude models
+- **Condition**: Model name contains "claude"
+- **Operation**: Limits `max_tokens` field to maximum 8192
+
+### 5. Remove Unsupported Stream Options
+- **Purpose**: Removes `stream_options` for older GPT models that don't support it
+- **Condition**: Model matches older GPT patterns and `stream_options` exists
+- **Operation**: Removes `stream_options` field
+
+## Configuration
+
+### Basic Usage
+
+```go
+import (
+    "github.com/labring/aiproxy/core/relay/plugin/patch"
+)
+
+// Create plugin - configuration is loaded from model config
+plugin := patch.New()
+```
+
+### Configuration
+
+The patch plugin loads configuration from the model's plugin configuration in the database. The configuration should be stored in the model config's `plugin` field under the key `"patch"`.
+
+Example model config plugin configuration:
+
+```json
+{
+  "patch": {
+    "enable": true,
+    "user_patches": [
+      {
+        "name": "custom_temperature_limit",
+        "description": "Limit temperature for specific models",
+        "conditions": [
+          {
+            "key": "model", 
+            "operator": "contains",
+            "value": "gpt-4"
+          }
+        ],
+        "operations": [
+          {
+            "op": "limit",
+            "key": "temperature", 
+            "value": 1.0
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+### Predefined Patches
+
+The plugin comes with built-in predefined patches that are always enabled:
+
+- **DeepSeek max_tokens limit**: Automatically limits `max_tokens` to 16000 for DeepSeek models
+- **GPT-5 compatibility**: Converts `max_tokens` to `max_completion_tokens` for GPT-5 models
+- **O1 models compatibility**: Same conversion for o1, o1-preview, and o1-mini models
+- **Claude max_tokens limit**: Limits `max_tokens` to 8192 for Claude models
+- **Stream options cleanup**: Removes unsupported `stream_options` for older GPT models
+
+These predefined patches run automatically and cannot be disabled.
+
+## Condition Operators
+
+- `equals`: Exact string match
+- `not_equals`: Not equal to string
+- `contains`: String contains substring
+- `not_contains`: String does not contain substring
+- `regex`: Regular expression match
+- `exists`: Field exists (non-nil)
+- `not_exists`: Field does not exist (nil)
+
+## Operation Types
+
+- `set`: Set field to a specific value
+- `delete`: Remove field from JSON
+- `add`: Add field only if it doesn't exist
+- `limit`: Limit numeric field to maximum value
+
+## Special Keys
+
+- `model`: References the actual model name from meta
+- `original_model`: References the original model name from meta
+- Any other key: References JSON field (supports dot notation)
+
+## Placeholder Syntax
+
+Use `{{field_name}}` to reference values from the JSON data:
+
+```go
+{
+    Op:    patch.OpSet,
+    Key:   "max_completion_tokens",
+    Value: "{{max_tokens}}", // Will be replaced with actual max_tokens value
+}
+```
+
+## Nested Field Access
+
+Use dot notation to access nested fields:
+
+```go
+{
+    Key: "parameters.max_tokens",  // Accesses parameters.max_tokens
+    // ...
+}
+```
+
+## Integration with Plugin System
+
+```go
+import (
+    "github.com/labring/aiproxy/core/relay/plugin"
+    "github.com/labring/aiproxy/core/relay/plugin/patch"
+)
+
+// Create patch plugin
+patchPlugin := patch.New()
+
+// Wrap adaptor with plugin
+adaptor = plugin.WrapperAdaptor(adaptor, patchPlugin)
+```
+
+## Performance Considerations
+
+- Uses sonic library for high-performance JSON processing
+- Efficient condition evaluation with early termination
+- Minimal memory allocation for unchanged requests
+- Lazy evaluation of patches (only applied when conditions match)
+
+## Error Handling
+
+- Graceful degradation: if patching fails, original request is preserved
+- Detailed logging of patch failures
+- Type-safe operations with proper error checking
+
+## Examples
+
+### Example 1: Model-specific Max Tokens
+
+```json
+{
+    "name": "anthropic_max_tokens",
+    "description": "Set appropriate max_tokens for Anthropic models",
+    "conditions": [
+        {
+            "key": "model",
+            "operator": "contains",
+            "value": "claude"
+        }
+    ],
+    "operations": [
+        {
+            "op": "limit",
+            "key": "max_tokens",
+            "value": 4096
+        }
+    ]
+}
+```
+
+### Example 2: Add Default Parameters
+
+```json
+{
+    "name": "add_default_temperature",
+    "description": "Add default temperature if not specified",
+    "conditions": [
+        {
+            "key": "temperature",
+            "operator": "not_exists",
+            "value": ""
+        }
+    ],
+    "operations": [
+        {
+            "op": "add",
+            "key": "temperature",
+            "value": 0.7
+        }
+    ]
+}
+```
+
+### Example 3: Complex Conditional Logic
+
+```json
+{
+    "name": "streaming_optimization",
+    "description": "Optimize streaming for specific models",
+    "conditions": [
+        {
+            "key": "stream",
+            "operator": "equals",
+            "value": "true"
+        },
+        {
+            "key": "model",
+            "operator": "regex",
+            "value": "^gpt-4"
+        }
+    ],
+    "operations": [
+        {
+            "op": "set",
+            "key": "stream_options.include_usage",
+            "value": true
+        }
+    ]
+}
+```

core/relay/plugin/patch/README.zh.md

@@ -0,0 +1,263 @@
+# Patch 插件
+
+Patch 插件提供了强大的 JSON 请求修改功能，使用 sonic 库实现高性能 JSON 处理。它允许您基于模型类型、字段值或自定义条件自动修改 API 请求。
+
+## 功能特性
+
+- **高性能**: 使用字节跳动的 sonic 库进行快速 JSON 解析和操作
+- **预定义补丁**: 内置常见场景的补丁（DeepSeek max_tokens 限制、GPT-5 兼容性等）
+- **用户自定义补丁**: 灵活的配置系统支持自定义补丁
+- **条件逻辑**: 基于模型类型、字段值或复杂条件应用补丁
+- **多种操作**: 支持设置、删除、添加和限制 JSON 字段的操作
+- **嵌套字段支持**: 使用点语法修改嵌套 JSON 结构
+- **占位符支持**: 使用 `{{field_name}}` 语法进行动态值替换
+
+## 预定义补丁
+
+插件包含几个内置补丁：
+
+### 1. DeepSeek Max Tokens 限制
+- **目的**: 将 DeepSeek 模型的 `max_tokens` 限制为 16000
+- **条件**: 模型名称包含 "deepseek"
+- **操作**: 将 `max_tokens` 字段限制为最大 16000
+
+### 2. GPT-5 Max Tokens 转换
+- **目的**: 为 GPT-5 模型将 `max_tokens` 转换为 `max_completion_tokens`
+- **条件**: 模型名称包含 "gpt-5" 且存在 `max_tokens` 字段
+- **操作**: 
+  - 将 `max_completion_tokens` 设置为 `max_tokens` 的值
+  - 删除 `max_tokens` 字段
+
+### 3. O1 模型 Max Tokens 转换
+- **目的**: 为 o1 模型将 `max_tokens` 转换为 `max_completion_tokens`
+- **条件**: 模型匹配 o1、o1-preview 或 o1-mini
+- **操作**: 与 GPT-5 转换相同
+
+### 4. Claude Max Tokens 限制
+- **目的**: 将 Claude 模型的 `max_tokens` 限制为 8192
+- **条件**: 模型名称包含 "claude"
+- **操作**: 将 `max_tokens` 字段限制为最大 8192
+
+### 5. 移除不支持的 Stream Options
+- **目的**: 为不支持的较旧 GPT 模型移除 `stream_options`
+- **条件**: 模型匹配较旧的 GPT 模式且存在 `stream_options`
+- **操作**: 删除 `stream_options` 字段
+
+## 配置
+
+### 基本用法
+
+```go
+import (
+    "github.com/labring/aiproxy/core/relay/plugin/patch"
+)
+
+// 创建插件 - 配置从模型配置中加载
+plugin := patch.New()
+```
+
+### 配置
+
+patch插件从数据库中模型的插件配置中加载配置。配置应存储在模型配置的`plugin`字段中，键名为`"patch"`。
+
+模型配置插件配置示例：
+
+```json
+{
+  "patch": {
+    "enable": true,
+    "user_patches": [
+      {
+        "name": "custom_temperature_limit",
+        "description": "为特定模型限制温度值",
+        "conditions": [
+          {
+            "key": "model", 
+            "operator": "contains",
+            "value": "gpt-4"
+          }
+        ],
+        "operations": [
+          {
+            "op": "limit",
+            "key": "temperature", 
+            "value": 1.0
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+### 预定义补丁
+
+插件包含内置的预定义补丁，这些补丁始终启用：
+
+- **DeepSeek max_tokens限制**: 自动将DeepSeek模型的`max_tokens`限制为16000
+- **GPT-5兼容性**: 为GPT-5模型将`max_tokens`转换为`max_completion_tokens`
+- **O1模型兼容性**: 为o1、o1-preview和o1-mini模型进行相同转换
+- **Claude max_tokens限制**: 将Claude模型的`max_tokens`限制为8192
+- **Stream选项清理**: 为较旧的GPT模型移除不支持的`stream_options`
+
+这些预定义补丁自动运行且无法禁用。
+
+## 条件操作符
+
+- `equals`: 精确字符串匹配
+- `not_equals`: 不等于字符串
+- `contains`: 字符串包含子字符串
+- `not_contains`: 字符串不包含子字符串
+- `regex`: 正则表达式匹配
+- `exists`: 字段存在（非空）
+- `not_exists`: 字段不存在（空）
+
+## 操作类型
+
+- `set`: 将字段设置为特定值
+- `delete`: 从 JSON 中删除字段
+- `add`: 仅当字段不存在时添加字段
+- `limit`: 将数值字段限制为最大值
+
+## 特殊键
+
+- `model`: 引用 meta 中的实际模型名称
+- `original_model`: 引用 meta 中的原始模型名称
+- 任何其他键: 引用 JSON 字段（支持点语法）
+
+## 占位符语法
+
+使用 `{{field_name}}` 引用 JSON 数据中的值：
+
+```go
+{
+    Op:    patch.OpSet,
+    Key:   "max_completion_tokens",
+    Value: "{{max_tokens}}", // 将被替换为实际的 max_tokens 值
+}
+```
+
+## 嵌套字段访问
+
+使用点语法访问嵌套字段：
+
+```go
+{
+    Key: "parameters.max_tokens",  // 访问 parameters.max_tokens
+    // ...
+}
+```
+
+## 与插件系统集成
+
+```go
+import (
+    "github.com/labring/aiproxy/core/relay/plugin"
+    "github.com/labring/aiproxy/core/relay/plugin/patch"
+)
+
+// 创建 patch 插件
+patchPlugin := patch.New()
+
+// 用插件包装适配器
+adaptor = plugin.WrapperAdaptor(adaptor, patchPlugin)
+```
+
+## 性能考虑
+
+- 使用 sonic 库进行高性能 JSON 处理
+- 高效的条件评估，支持早期终止
+- 对未更改的请求最小化内存分配
+- 延迟评估补丁（仅在条件匹配时应用）
+
+## 错误处理
+
+- 优雅降级：如果补丁失败，保留原始请求
+- 详细的补丁失败日志记录
+- 具有适当错误检查的类型安全操作
+
+## 示例
+
+### 示例 1: 模型特定的 Max Tokens
+
+```json
+{
+    "name": "anthropic_max_tokens",
+    "description": "为 Anthropic 模型设置适当的 max_tokens",
+    "conditions": [
+        {
+            "key": "model",
+            "operator": "contains",
+            "value": "claude"
+        }
+    ],
+    "operations": [
+        {
+            "op": "limit",
+            "key": "max_tokens",
+            "value": 4096
+        }
+    ]
+}
+```
+
+### 示例 2: 添加默认参数
+
+```json
+{
+    "name": "add_default_temperature",
+    "description": "如果未指定则添加默认温度值",
+    "conditions": [
+        {
+            "key": "temperature",
+            "operator": "not_exists",
+            "value": ""
+        }
+    ],
+    "operations": [
+        {
+            "op": "add",
+            "key": "temperature",
+            "value": 0.7
+        }
+    ]
+}
+```
+
+### 示例 3: 复杂条件逻辑
+
+```json
+{
+    "name": "streaming_optimization",
+    "description": "为特定模型优化流式处理",
+    "conditions": [
+        {
+            "key": "stream",
+            "operator": "equals",
+            "value": "true"
+        },
+        {
+            "key": "model",
+            "operator": "regex",
+            "value": "^gpt-4"
+        }
+    ],
+    "operations": [
+        {
+            "op": "set",
+            "key": "stream_options.include_usage",
+            "value": true
+        }
+    ]
+}
+```
+
+## 使用场景
+
+1. **模型兼容性**: 自动转换不同 API 之间的参数格式
+2. **令牌限制**: 基于模型能力限制 max_tokens
+3. **参数清理**: 移除特定模型不支持的参数
+4. **默认值设置**: 为缺失的参数添加合理默认值
+5. **API 版本适配**: 处理不同 API 版本之间的差异
+
+这个插件设计简洁而强大，可以轻松扩展以支持新的补丁规则和操作类型。

core/relay/plugin/patch/config.go

@@ -0,0 +1,189 @@
+// Package patch provides configuration types and structures for the patch plugin.
+package patch
+
+import "github.com/bytedance/sonic/ast"
+
+// Config holds the configuration for the patch plugin
+type Config struct {
+	// Force Enabled
+
+	// UserPatches are user-defined custom patches
+	UserPatches []PatchRule `json:"user_patches,omitempty"`
+}
+
+// PatchRule defines a complete patch rule with conditions and operations
+type PatchRule struct {
+	// Name is a descriptive name for this patch rule
+	Name string `json:"name"`
+	// Description explains what this patch does
+	Description string `json:"description,omitempty"`
+	// Conditions determine when this patch should be applied
+	Conditions []PatchCondition `json:"conditions,omitempty"`
+	// ConditionLogic defines how conditions are combined (default: "and")
+	ConditionLogic LogicOperator `json:"condition_logic,omitempty"`
+	// Operations define what modifications to make
+	Operations []PatchOperation `json:"operations"`
+}
+
+// PatchCondition defines when a patch should be applied
+type PatchCondition struct {
+	// Key is the field to check (supports dot notation for nested fields)
+	// Special keys: "model", "original_model"
+	Key string `json:"key"`
+	// Operator defines how to compare the value
+	Operator ConditionOperator `json:"operator"`
+	// Value is the value to compare against
+	Value string `json:"value"`
+	// Values is an array of values for 'in' and 'not_in' operators
+	Values []string `json:"values,omitempty"`
+	// Negate inverts the result of this condition (for "not" logic)
+	Negate bool `json:"negate,omitempty"`
+}
+
+type PatchFunction func(root *ast.Node) (bool, error)
+
+// PatchOperation defines a modification to make to the JSON
+type PatchOperation struct {
+	// Op is the operation type
+	Op OperationType `json:"op"`
+	// Key is the field to modify (supports dot notation for nested fields)
+	Key string `json:"key"`
+	// Value is the new value to set (not used for delete operations)
+	Value any `json:"value,omitempty"`
+	// Function is the inline Function code for OpFunction operations
+	Function PatchFunction `json:"-"`
+}
+
+// ConditionOperator defines how to evaluate a condition
+type ConditionOperator string
+
+const (
+	OperatorEquals      ConditionOperator = "equals"
+	OperatorNotEquals   ConditionOperator = "not_equals"
+	OperatorContains    ConditionOperator = "contains"
+	OperatorNotContains ConditionOperator = "not_contains"
+	OperatorRegex       ConditionOperator = "regex"
+	OperatorExists      ConditionOperator = "exists"
+	OperatorNotExists   ConditionOperator = "not_exists"
+	OperatorHasPrefix   ConditionOperator = "has_prefix"
+	OperatorHasSuffix   ConditionOperator = "has_suffix"
+	OperatorGreaterThan ConditionOperator = "greater_than"
+	OperatorLessThan    ConditionOperator = "less_than"
+	OperatorGreaterEq   ConditionOperator = "greater_eq"
+	OperatorLessEq      ConditionOperator = "less_eq"
+	OperatorIn          ConditionOperator = "in"
+	OperatorNotIn       ConditionOperator = "not_in"
+)
+
+// LogicOperator defines how multiple conditions are combined
+type LogicOperator string
+
+const (
+	// LogicAnd requires all conditions to be true (default)
+	LogicAnd LogicOperator = "and"
+	// LogicOr requires at least one condition to be true
+	LogicOr LogicOperator = "or"
+)
+
+// OperationType defines the type of operation to perform
+type OperationType string
+
+const (
+	// OpSet sets a field to a specific value
+	OpSet OperationType = "set"
+	// OpDelete removes a field
+	OpDelete OperationType = "delete"
+	// OpAdd adds a field only if it doesn't exist
+	OpAdd OperationType = "add"
+	// OpLimit limits a numeric field to a maximum value
+	OpLimit OperationType = "limit"
+	// OpIncrement increments a numeric field by a value
+	OpIncrement OperationType = "increment"
+	// OpDecrement decrements a numeric field by a value
+	OpDecrement OperationType = "decrement"
+	// OpMultiply multiplies a numeric field by a value
+	OpMultiply OperationType = "multiply"
+	// OpDivide divides a numeric field by a value
+	OpDivide OperationType = "divide"
+	// OpAppend appends value to an array field
+	OpAppend OperationType = "append"
+	// OpPrepend prepends value to an array field
+	OpPrepend OperationType = "prepend"
+	// OpFunction executes an inline function on the field
+	OpFunction OperationType = "function"
+)
+
+// DefaultPredefinedPatches are built-in patches that are always available
+var DefaultPredefinedPatches = []PatchRule{
+	{
+		Name:           "deepseek_max_tokens_limit",
+		Description:    "Limit max_tokens to 16000 for DeepSeek models",
+		ConditionLogic: LogicOr,
+		Conditions: []PatchCondition{
+			{
+				Key:      "model",
+				Operator: OperatorContains,
+				Value:    "deepseek-v3",
+			},
+			{
+				Key:      "model",
+				Operator: OperatorContains,
+				Value:    "deepseek-chat",
+			},
+		},
+		Operations: []PatchOperation{
+			{
+				Op:    OpLimit,
+				Key:   "max_tokens",
+				Value: 16384,
+			},
+		},
+	},
+	{
+		Name:        "gpt5_max_tokens_to_max_completion_tokens",
+		Description: "Convert max_tokens to max_completion_tokens for GPT-5 models",
+		Conditions: []PatchCondition{
+			{
+				Key:      "model",
+				Operator: OperatorContains,
+				Value:    "gpt-5",
+			},
+			{
+				Key:      "max_tokens",
+				Operator: OperatorExists,
+			},
+		},
+		Operations: []PatchOperation{
+			{
+				Op:    OpSet,
+				Key:   "max_completion_tokens",
+				Value: "{{max_tokens}}", // Special placeholder that will be replaced with actual max_tokens value
+			},
+			{
+				Op:  OpDelete,
+				Key: "max_tokens",
+			},
+		},
+	},
+	{
+		Name:        "gpt5_remove_temperature",
+		Description: "Remove temperature field for GPT-5 models",
+		Conditions: []PatchCondition{
+			{
+				Key:      "model",
+				Operator: OperatorContains,
+				Value:    "gpt-5",
+			},
+			{
+				Key:      "temperature",
+				Operator: OperatorExists,
+			},
+		},
+		Operations: []PatchOperation{
+			{
+				Op:  OpDelete,
+				Key: "temperature",
+			},
+		},
+	},
+}

core/relay/plugin/patch/example.json

@@ -0,0 +1,158 @@
+{
+  "user_patches": [
+    {
+      "name": "custom_temperature_limit",
+      "description": "Limit temperature to 1.5 for all models",
+      "conditions": [
+        {
+          "key": "temperature",
+          "operator": "exists",
+          "value": ""
+        }
+      ],
+      "operations": [
+        {
+          "op": "limit",
+          "key": "temperature",
+          "value": 1.5
+        }
+      ]
+    },
+    {
+      "name": "add_default_top_p",
+      "description": "Add default top_p if not specified",
+      "conditions": [
+        {
+          "key": "top_p",
+          "operator": "not_exists",
+          "value": ""
+        }
+      ],
+      "operations": [
+        {
+          "op": "add",
+          "key": "top_p",
+          "value": 0.9
+        }
+      ]
+    },
+    {
+      "name": "remove_system_fingerprint_for_old_models",
+      "description": "Remove system_fingerprint for models that don't support it",
+      "conditions": [
+        {
+          "key": "model",
+          "operator": "regex",
+          "value": "gpt-3\\.5-turbo"
+        },
+        {
+          "key": "system_fingerprint",
+          "operator": "exists", 
+          "value": ""
+        }
+      ],
+      "operations": [
+        {
+          "op": "delete",
+          "key": "system_fingerprint"
+        }
+      ]
+    },
+    {
+      "name": "anthropic_specific_settings",
+      "description": "Apply Anthropic-specific optimizations",
+      "conditions": [
+        {
+          "key": "model",
+          "operator": "contains",
+          "value": "claude"
+        }
+      ],
+      "operations": [
+        {
+          "op": "limit",
+          "key": "max_tokens",
+          "value": 4096
+        },
+        {
+          "op": "set",
+          "key": "anthropic_version",
+          "value": "2023-06-01"
+        }
+      ]
+    },
+    {
+      "name": "convert_legacy_stop_to_stop_sequences",
+      "description": "Convert stop parameter to stop_sequences for Claude models",
+      "conditions": [
+        {
+          "key": "model",
+          "operator": "contains",
+          "value": "claude"
+        },
+        {
+          "key": "stop",
+          "operator": "exists",
+          "value": ""
+        }
+      ],
+      "operations": [
+        {
+          "op": "set",
+          "key": "stop_sequences",
+          "value": "{{stop}}"
+        },
+        {
+          "op": "delete",
+          "key": "stop"
+        }
+      ]
+    },
+    {
+      "name": "nested_parameter_example",
+      "description": "Example of setting nested parameters",
+      "conditions": [
+        {
+          "key": "model",
+          "operator": "equals",
+          "value": "example-model"
+        }
+      ],
+      "operations": [
+        {
+          "op": "set",
+          "key": "generation_config.max_output_tokens",
+          "value": 2048
+        },
+        {
+          "op": "set", 
+          "key": "generation_config.temperature",
+          "value": 0.7
+        },
+        {
+          "op": "set",
+          "key": "safety_settings.category",
+          "value": "HARM_CATEGORY_DANGEROUS_CONTENT"
+        }
+      ]
+    },
+    {
+      "name": "model_specific_token_limits",
+      "description": "Set appropriate token limits based on model capabilities",
+      "conditions": [
+        {
+          "key": "original_model", 
+          "operator": "regex",
+          "value": "gpt-4-turbo"
+        }
+      ],
+      "operations": [
+        {
+          "op": "limit",
+          "key": "max_tokens",
+          "value": 4096
+        }
+      ]
+    }
+  ]
+}

core/relay/plugin/patch/patch.go

@@ -0,0 +1,793 @@
+// Package patch provides high-performance JSON request patching functionality using sonic.
+// It allows automatic modification of API requests based on conditions and rules.
+package patch
+
+import (
+	"fmt"
+	"net/http"
+	"regexp"
+	"slices"
+	"strconv"
+	"strings"
+
+	"github.com/bytedance/sonic"
+	"github.com/bytedance/sonic/ast"
+	"github.com/labring/aiproxy/core/common"
+	"github.com/labring/aiproxy/core/relay/adaptor"
+	"github.com/labring/aiproxy/core/relay/meta"
+	"github.com/labring/aiproxy/core/relay/plugin"
+	"github.com/labring/aiproxy/core/relay/plugin/noop"
+)
+
+var _ plugin.Plugin = (*Plugin)(nil)
+
+const PluginName = "patch"
+
+// LazyPatchData represents data to be applied by patch plugin later
+type LazyPatchData struct {
+	Source string `json:"source"` // Source plugin name
+	Data   any    `json:"data"`   // Data to be patched
+}
+
+const lazyPatchesKey = "_lazy_patches"
+
+// Plugin implements JSON request patching functionality
+type Plugin struct {
+	noop.Noop
+}
+
+// NewPatchPlugin creates a new patch plugin instance
+func NewPatchPlugin() *Plugin {
+	return &Plugin{}
+}
+
+// AddLazyPatch adds data to the lazy patch queue in meta
+func AddLazyPatch(meta *meta.Meta, patch PatchOperation) {
+	meta.PushToSlice(lazyPatchesKey, patch)
+}
+
+// GetLazyPatches retrieves all lazy patch data from meta
+func GetLazyPatches(meta *meta.Meta) []PatchOperation {
+	slice := meta.GetSlice(lazyPatchesKey)
+	if slice == nil {
+		return nil
+	}
+
+	patches := make([]PatchOperation, 0, len(slice))
+	for _, item := range slice {
+		if patch, ok := item.(PatchOperation); ok {
+			patches = append(patches, patch)
+		}
+	}
+
+	return patches
+}
+
+// ConvertRequest applies JSON patches to the request body
+func (p *Plugin) ConvertRequest(
+	meta *meta.Meta,
+	store adaptor.Store,
+	req *http.Request,
+	do adaptor.ConvertRequest,
+) (adaptor.ConvertResult, error) {
+	// Load patch configuration from model config
+	config := p.loadConfig(meta)
+
+	bodyBytes, err := common.GetRequestBodyReusable(req)
+	if err != nil {
+		return do.ConvertRequest(meta, store, req)
+	}
+
+	// Apply patches
+	patchedBody, modified, err := p.ApplyPatches(bodyBytes, meta, config)
+	if err != nil {
+		return do.ConvertRequest(meta, store, req)
+	}
+
+	// If no modifications were made, return original
+	if !modified {
+		return do.ConvertRequest(meta, store, req)
+	}
+
+	common.SetRequestBody(req, patchedBody)
+	defer func() {
+		common.SetRequestBody(req, bodyBytes)
+	}()
+
+	return do.ConvertRequest(meta, store, req)
+}
+
+// loadConfig loads patch configuration from model config
+func (p *Plugin) loadConfig(meta *meta.Meta) *Config {
+	// Load plugin config from model config
+	var config Config
+	if err := meta.ModelConfig.LoadPluginConfig(PluginName, &config); err != nil {
+		return &Config{}
+	}
+
+	return &config
+}
+
+// ApplyPatches applies all applicable patches to the JSON body
+func (p *Plugin) ApplyPatches(
+	bodyBytes []byte,
+	meta *meta.Meta,
+	config *Config,
+) ([]byte, bool, error) {
+	// Parse JSON using sonic AST
+	node, err := sonic.Get(bodyBytes)
+	if err != nil {
+		// If it's not valid JSON, return as is
+		return bodyBytes, false, nil
+	}
+
+	modified := false
+
+	// Apply predefined patches (always enabled)
+	for _, patch := range DefaultPredefinedPatches {
+		if p.shouldApplyPatch(&patch, &node, meta) {
+			if p.applyPatch(&patch, &node) {
+				modified = true
+			}
+		}
+	}
+
+	// Apply lazy patches from meta
+	if p.applyLazyPatches(&node, meta) {
+		modified = true
+	}
+
+	// Apply user-defined patches
+	for _, patch := range config.UserPatches {
+		if p.shouldApplyPatch(&patch, &node, meta) {
+			if p.applyPatch(&patch, &node) {
+				modified = true
+			}
+		}
+	}
+
+	if !modified {
+		return bodyBytes, false, nil
+	}
+
+	// Marshal back to JSON using sonic
+	patchedBytes, err := node.MarshalJSON()
+	if err != nil {
+		return bodyBytes, false, fmt.Errorf("failed to marshal patched JSON: %w", err)
+	}
+
+	return patchedBytes, true, nil
+}
+
+// shouldApplyPatch determines if a patch should be applied based on conditions
+func (p *Plugin) shouldApplyPatch(patch *PatchRule, root *ast.Node, meta *meta.Meta) bool {
+	// Check if the patch has conditions
+	if len(patch.Conditions) == 0 {
+		return true // No conditions means always apply
+	}
+
+	// Default to "and" logic if not specified
+	logic := patch.ConditionLogic
+	if logic == "" {
+		logic = LogicAnd
+	}
+
+	switch logic {
+	case LogicOr:
+		// At least one condition must be satisfied
+		for _, condition := range patch.Conditions {
+			if p.evaluateCondition(&condition, root, meta) {
+				return true
+			}
+		}
+
+		return false
+	case LogicAnd:
+		fallthrough
+	default:
+		// All conditions must be satisfied
+		for _, condition := range patch.Conditions {
+			if !p.evaluateCondition(&condition, root, meta) {
+				return false
+			}
+		}
+
+		return true
+	}
+}
+
+// evaluateCondition evaluates a single condition
+func (p *Plugin) evaluateCondition(
+	condition *PatchCondition,
+	root *ast.Node,
+	meta *meta.Meta,
+) bool {
+	var actualValue any
+
+	// Get the value to check
+	switch condition.Key {
+	case "model":
+		actualValue = meta.ActualModel
+	case "original_model":
+		actualValue = meta.OriginModel
+	default:
+		// Look in JSON data
+		actualValue = p.getNestedValueAST(root, condition.Key)
+	}
+
+	// Convert to string for comparison
+	actualStr := fmt.Sprintf("%v", actualValue)
+
+	var result bool
+
+	// Apply the operator
+	switch condition.Operator {
+	case OperatorEquals:
+		result = actualStr == condition.Value
+	case OperatorNotEquals:
+		result = actualStr != condition.Value
+	case OperatorContains:
+		result = strings.Contains(actualStr, condition.Value)
+	case OperatorNotContains:
+		result = !strings.Contains(actualStr, condition.Value)
+	case OperatorHasPrefix:
+		result = strings.HasPrefix(actualStr, condition.Value)
+	case OperatorHasSuffix:
+		result = strings.HasSuffix(actualStr, condition.Value)
+	case OperatorRegex:
+		matched, err := regexp.MatchString(condition.Value, actualStr)
+		result = err == nil && matched
+	case OperatorExists:
+		result = actualValue != nil
+	case OperatorNotExists:
+		result = actualValue == nil
+	case OperatorGreaterThan:
+		result = p.compareNumeric(actualValue, condition.Value, ">")
+	case OperatorLessThan:
+		result = p.compareNumeric(actualValue, condition.Value, "<")
+	case OperatorGreaterEq:
+		result = p.compareNumeric(actualValue, condition.Value, ">=")
+	case OperatorLessEq:
+		result = p.compareNumeric(actualValue, condition.Value, "<=")
+	case OperatorIn:
+		result = p.stringInSlice(actualStr, condition.Values)
+	case OperatorNotIn:
+		result = !p.stringInSlice(actualStr, condition.Values)
+	default:
+		result = false
+	}
+
+	// Apply negation if specified
+	if condition.Negate {
+		result = !result
+	}
+
+	return result
+}
+
+// applyPatch applies a single patch to the JSON data
+func (p *Plugin) applyPatch(patch *PatchRule, root *ast.Node) bool {
+	modified := false
+
+	for _, operation := range patch.Operations {
+		operationModified, err := p.applyOperation(&operation, root)
+		if err == nil && operationModified {
+			modified = true
+		}
+	}
+
+	return modified
+}
+
+// applyOperation applies a single operation
+func (p *Plugin) applyOperation(operation *PatchOperation, root *ast.Node) (bool, error) {
+	// Resolve placeholders in the value
+	resolvedValue := p.resolvePlaceholdersAST(operation.Value, root)
+
+	switch operation.Op {
+	case OpSet:
+		return p.setValueAST(root, operation.Key, resolvedValue), nil
+	case OpDelete:
+		return p.deleteValueAST(root, operation.Key), nil
+	case OpAdd:
+		// For add, we only set if the key doesn't exist
+		if p.getNestedValueAST(root, operation.Key) == nil {
+			return p.setValueAST(root, operation.Key, resolvedValue), nil
+		}
+		return false, nil
+	case OpLimit:
+		return p.limitValueAST(root, operation.Key, resolvedValue), nil
+	case OpIncrement:
+		return p.incrementValueAST(root, operation.Key, resolvedValue), nil
+	case OpDecrement:
+		return p.decrementValueAST(root, operation.Key, resolvedValue), nil
+	case OpMultiply:
+		return p.multiplyValueAST(root, operation.Key, resolvedValue), nil
+	case OpDivide:
+		return p.divideValueAST(root, operation.Key, resolvedValue), nil
+	case OpAppend:
+		return p.appendValueAST(root, operation.Key, resolvedValue), nil
+	case OpPrepend:
+		return p.prependValueAST(root, operation.Key, resolvedValue), nil
+	case OpFunction:
+		return operation.Function(root)
+	default:
+		return false, nil
+	}
+}
+
+// getNestedValueAST retrieves a value from nested JSON structure using AST
+func (p *Plugin) getNestedValueAST(root *ast.Node, key string) any {
+	keys := strings.Split(key, ".")
+	current := root
+
+	for _, k := range keys {
+		if current.TypeSafe() != ast.V_OBJECT {
+			return nil
+		}
+
+		next := current.Get(k)
+		if !next.Valid() {
+			return nil
+		}
+
+		current = next
+	}
+
+	// Convert AST node to interface{}
+	val, _ := current.Interface()
+
+	return val
+}
+
+// setValueAST sets a value in nested JSON structure using AST
+func (p *Plugin) setValueAST(root *ast.Node, key string, value any) bool {
+	keys := strings.Split(key, ".")
+	current := root
+
+	// Navigate to the parent of the target key
+	for i := range len(keys) - 1 {
+		if current.TypeSafe() != ast.V_OBJECT {
+			return false
+		}
+
+		next := current.Get(keys[i])
+		if !next.Valid() {
+			// Create new object if it doesn't exist
+			newObj := ast.NewObject([]ast.Pair{})
+			if _, err := current.Set(keys[i], newObj); err != nil {
+				return false
+			}
+
+			next = current.Get(keys[i])
+		}
+
+		current = next
+	}
+
+	if current.TypeSafe() != ast.V_OBJECT {
+		return false
+	}
+
+	finalKey := keys[len(keys)-1]
+	oldValue := current.Get(finalKey)
+
+	// Capture the old value BEFORE we modify the node
+	var (
+		oldVal      any
+		hasOldValue bool
+	)
+
+	if oldValue.Valid() {
+		oldVal, _ = oldValue.Interface()
+		hasOldValue = true
+	} else {
+		hasOldValue = false
+	}
+
+	// Create AST node from value
+	var newNode ast.Node
+	if value == nil {
+		newNode = ast.NewNull()
+	} else {
+		switch v := value.(type) {
+		case string:
+			newNode = ast.NewString(v)
+		case int:
+			newNode = ast.NewNumber(strconv.Itoa(v))
+		case int64:
+			newNode = ast.NewNumber(strconv.FormatInt(v, 10))
+		case float64:
+			newNode = ast.NewNumber(strconv.FormatFloat(v, 'f', -1, 64))
+		case bool:
+			newNode = ast.NewBool(v)
+		default:
+			// Try to marshal and parse
+			if bytes, err := sonic.Marshal(v); err == nil {
+				if node, err := sonic.Get(bytes); err == nil {
+					newNode = node
+				} else {
+					return false
+				}
+			} else {
+				return false
+			}
+		}
+	}
+
+	if _, err := current.Set(finalKey, newNode); err != nil {
+		return false
+	}
+
+	// Check if value actually changed
+	if hasOldValue {
+		newVal, _ := newNode.Interface()
+		changed := fmt.Sprintf("%v", oldVal) != fmt.Sprintf("%v", newVal)
+		return changed
+	}
+
+	return true
+}
+
+// deleteValueAST deletes a value from nested JSON structure using AST
+func (p *Plugin) deleteValueAST(root *ast.Node, key string) bool {
+	keys := strings.Split(key, ".")
+	current := root
+
+	// Navigate to the parent of the target key
+	for i := range len(keys) - 1 {
+		if current.TypeSafe() != ast.V_OBJECT {
+			return false
+		}
+
+		next := current.Get(keys[i])
+		if !next.Valid() {
+			return false
+		}
+
+		current = next
+	}
+
+	if current.TypeSafe() != ast.V_OBJECT {
+		return false
+	}
+
+	finalKey := keys[len(keys)-1]
+
+	oldValue := current.Get(finalKey)
+	if !oldValue.Valid() {
+		return false
+	}
+
+	if _, err := current.Unset(finalKey); err != nil {
+		return false
+	}
+
+	return true
+}
+
+// limitValueAST limits a numeric value to a maximum using AST
+func (p *Plugin) limitValueAST(root *ast.Node, key string, maxValue any) bool {
+	currentValue := p.getNestedValueAST(root, key)
+	if currentValue == nil {
+		return false
+	}
+
+	// Convert values to float64 for comparison
+	currentFloat, err := ToFloat64(currentValue)
+	if err != nil {
+		return false
+	}
+
+	maxFloat, err := ToFloat64(maxValue)
+	if err != nil {
+		return false
+	}
+
+	// If current value exceeds the limit, set it to the limit
+	if currentFloat > maxFloat {
+		result := p.setValueAST(root, key, maxValue)
+		return result
+	}
+
+	return false
+}
+
+// incrementValueAST increments a numeric value using AST
+func (p *Plugin) incrementValueAST(root *ast.Node, key string, incrementValue any) bool {
+	currentValue := p.getNestedValueAST(root, key)
+	if currentValue == nil {
+		return false
+	}
+
+	currentFloat, err := ToFloat64(currentValue)
+	if err != nil {
+		return false
+	}
+
+	incrementFloat, err := ToFloat64(incrementValue)
+	if err != nil {
+		return false
+	}
+
+	newValue := currentFloat + incrementFloat
+
+	return p.setValueAST(root, key, newValue)
+}
+
+// decrementValueAST decrements a numeric value using AST
+func (p *Plugin) decrementValueAST(root *ast.Node, key string, decrementValue any) bool {
+	currentValue := p.getNestedValueAST(root, key)
+	if currentValue == nil {
+		return false
+	}
+
+	currentFloat, err := ToFloat64(currentValue)
+	if err != nil {
+		return false
+	}
+
+	decrementFloat, err := ToFloat64(decrementValue)
+	if err != nil {
+		return false
+	}
+
+	newValue := currentFloat - decrementFloat
+
+	return p.setValueAST(root, key, newValue)
+}
+
+// multiplyValueAST multiplies a numeric value using AST
+func (p *Plugin) multiplyValueAST(root *ast.Node, key string, multiplierValue any) bool {
+	currentValue := p.getNestedValueAST(root, key)
+	if currentValue == nil {
+		return false
+	}
+
+	currentFloat, err := ToFloat64(currentValue)
+	if err != nil {
+		return false
+	}
+
+	multiplierFloat, err := ToFloat64(multiplierValue)
+	if err != nil {
+		return false
+	}
+
+	newValue := currentFloat * multiplierFloat
+
+	return p.setValueAST(root, key, newValue)
+}
+
+// divideValueAST divides a numeric value using AST
+func (p *Plugin) divideValueAST(root *ast.Node, key string, divisorValue any) bool {
+	currentValue := p.getNestedValueAST(root, key)
+	if currentValue == nil {
+		return false
+	}
+
+	currentFloat, err := ToFloat64(currentValue)
+	if err != nil {
+		return false
+	}
+
+	divisorFloat, err := ToFloat64(divisorValue)
+	if err != nil || divisorFloat == 0 {
+		return false
+	}
+
+	newValue := currentFloat / divisorFloat
+
+	return p.setValueAST(root, key, newValue)
+}
+
+// appendValueAST appends a value to an array using AST
+func (p *Plugin) appendValueAST(root *ast.Node, key string, value any) bool {
+	currentNode, exists := p.getNodeByKey(root, key)
+	if !exists {
+		// Create new array with the value
+		valueNode := p.createASTNode(value)
+		if !valueNode.Valid() {
+			return false
+		}
+
+		newArray := ast.NewArray([]ast.Node{valueNode})
+
+		return p.setValueAST(root, key, newArray)
+	}
+
+	if currentNode.TypeSafe() != ast.V_ARRAY {
+		return false
+	}
+
+	valueNode := p.createASTNode(value)
+	if !valueNode.Valid() {
+		return false
+	}
+
+	if err := currentNode.Add(valueNode); err != nil {
+		return false
+	}
+
+	return true
+}
+
+// prependValueAST prepends a value to an array using AST
+func (p *Plugin) prependValueAST(root *ast.Node, key string, value any) bool {
+	currentNode, exists := p.getNodeByKey(root, key)
+	if !exists {
+		// Create new array with the value
+		valueNode := p.createASTNode(value)
+		if !valueNode.Valid() {
+			return false
+		}
+
+		newArray := ast.NewArray([]ast.Node{valueNode})
+
+		return p.setValueAST(root, key, newArray)
+	}
+
+	if currentNode.TypeSafe() != ast.V_ARRAY {
+		return false
+	}
+
+	valueNode := p.createASTNode(value)
+	if !valueNode.Valid() {
+		return false
+	}
+
+	// Get all existing elements
+	length, err := currentNode.Len()
+	if err != nil {
+		return false
+	}
+
+	elements := make([]ast.Node, length+1)
+	elements[0] = valueNode
+
+	for i := range length {
+		elem := currentNode.Index(i)
+		if elem == nil {
+			return false
+		}
+
+		elements[i+1] = *elem
+	}
+
+	// Rebuild array
+	newArray := ast.NewArray(elements)
+
+	return p.setValueAST(root, key, newArray)
+}
+
+// getNodeByKey gets an AST node by key path
+func (p *Plugin) getNodeByKey(root *ast.Node, key string) (ast.Node, bool) {
+	keys := strings.Split(key, ".")
+	current := root
+
+	for _, k := range keys {
+		if current.TypeSafe() != ast.V_OBJECT {
+			return ast.Node{}, false
+		}
+
+		next := current.Get(k)
+		if !next.Valid() {
+			return ast.Node{}, false
+		}
+
+		current = next
+	}
+
+	return *current, true
+}
+
+// createASTNode creates an AST node from a value
+func (p *Plugin) createASTNode(value any) ast.Node {
+	if value == nil {
+		return ast.NewNull()
+	}
+
+	switch v := value.(type) {
+	case string:
+		return ast.NewString(v)
+	case int:
+		return ast.NewNumber(strconv.Itoa(v))
+	case int64:
+		return ast.NewNumber(strconv.FormatInt(v, 10))
+	case float64:
+		return ast.NewNumber(strconv.FormatFloat(v, 'f', -1, 64))
+	case bool:
+		return ast.NewBool(v)
+	default:
+		// Try to marshal and parse
+		if bytes, err := sonic.Marshal(v); err == nil {
+			if node, err := sonic.Get(bytes); err == nil {
+				return node
+			}
+		}
+
+		return ast.Node{}
+	}
+}
+
+func ToFloat64(v any) (float64, error) {
+	switch val := v.(type) {
+	case float64:
+		return val, nil
+	case float32:
+		return float64(val), nil
+	case int:
+		return float64(val), nil
+	case int32:
+		return float64(val), nil
+	case int64:
+		return float64(val), nil
+	case string:
+		return strconv.ParseFloat(val, 64)
+	default:
+		return 0, fmt.Errorf("cannot convert %T to float64", v)
+	}
+}
+
+// compareNumeric compares two numeric values
+func (p *Plugin) compareNumeric(actualValue any, expectedValue, operator string) bool {
+	actualFloat, err := ToFloat64(actualValue)
+	if err != nil {
+		return false
+	}
+
+	expectedFloat, err := strconv.ParseFloat(expectedValue, 64)
+	if err != nil {
+		return false
+	}
+
+	switch operator {
+	case ">":
+		return actualFloat > expectedFloat
+	case "<":
+		return actualFloat < expectedFloat
+	case ">=":
+		return actualFloat >= expectedFloat
+	case "<=":
+		return actualFloat <= expectedFloat
+	default:
+		return false
+	}
+}
+
+// stringInSlice checks if a string is in a slice
+func (p *Plugin) stringInSlice(str string, slice []string) bool {
+	return slices.Contains(slice, str)
+}
+
+// applyLazyPatches applies patches queued in meta from other plugins
+func (p *Plugin) applyLazyPatches(root *ast.Node, meta *meta.Meta) bool {
+	lazyPatches := GetLazyPatches(meta)
+	if len(lazyPatches) == 0 {
+		return false
+	}
+
+	modified := false
+	for _, lazyPatch := range lazyPatches {
+		if opModified, err := p.applyOperation(&lazyPatch, root); err == nil && opModified {
+			modified = true
+		}
+	}
+
+	return modified
+}
+
+// resolvePlaceholdersAST replaces placeholders in values with actual values from JSON data using AST
+func (p *Plugin) resolvePlaceholdersAST(value any, root *ast.Node) any {
+	if strValue, ok := value.(string); ok {
+		// Check if it's a placeholder pattern {{key}}
+		if strings.HasPrefix(strValue, "{{") && strings.HasSuffix(strValue, "}}") {
+			placeholderKey := strValue[2 : len(strValue)-2]
+			if actualValue := p.getNestedValueAST(root, placeholderKey); actualValue != nil {
+				return actualValue
+			}
+		}
+	}
+
+	return value
+}

core/relay/plugin/patch/patch_test.go

@@ -0,0 +1,755 @@
+package patch_test
+
+import (
+	"testing"
+
+	"github.com/bytedance/sonic"
+	"github.com/labring/aiproxy/core/relay/meta"
+	"github.com/labring/aiproxy/core/relay/plugin/patch"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNew(t *testing.T) {
+	plugin := patch.NewPatchPlugin()
+	assert.NotNil(t, plugin)
+	assert.True(t, len(patch.DefaultPredefinedPatches) > 0)
+}
+
+func TestApplyPatches_DeepSeekMaxTokensLimit(t *testing.T) {
+	plugin := patch.NewPatchPlugin()
+	config := &patch.Config{}
+
+	testCases := []struct {
+		name              string
+		input             map[string]any
+		actualModel       string
+		expectedMaxTokens int
+		shouldModify      bool
+	}{
+		{
+			name: "deepseek model with high max_tokens",
+			input: map[string]any{
+				"model":      "deepseek-chat",
+				"max_tokens": 20000,
+			},
+			actualModel:       "deepseek-chat",
+			expectedMaxTokens: 16384,
+			shouldModify:      true,
+		},
+		{
+			name: "deepseek model with high max_tokens",
+			input: map[string]any{
+				"model":      "deepseek-v3",
+				"max_tokens": 20000,
+			},
+			actualModel:       "deepseek-v3",
+			expectedMaxTokens: 16384,
+			shouldModify:      true,
+		},
+		{
+			name: "deepseek model with low max_tokens",
+			input: map[string]any{
+				"model":      "deepseek-chat",
+				"max_tokens": 8000,
+			},
+			actualModel:       "deepseek-chat",
+			expectedMaxTokens: 8000,
+			shouldModify:      false,
+		},
+		{
+			name: "non-deepseek model",
+			input: map[string]any{
+				"model":      "gpt-4",
+				"max_tokens": 20000,
+			},
+			actualModel:       "gpt-4",
+			expectedMaxTokens: 20000,
+			shouldModify:      false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			inputBytes, err := sonic.Marshal(tc.input)
+			require.NoError(t, err)
+
+			meta := &meta.Meta{ActualModel: tc.actualModel}
+			outputBytes, modified, err := plugin.ApplyPatches(inputBytes, meta, config)
+			require.NoError(t, err)
+			assert.Equal(t, tc.shouldModify, modified)
+
+			var output map[string]any
+
+			err = sonic.Unmarshal(outputBytes, &output)
+			require.NoError(t, err)
+
+			if maxTokens, exists := output["max_tokens"]; exists {
+				maxTokensFloat, ok := maxTokens.(float64)
+				require.True(t, ok, "max_tokens should be float64")
+				assert.Equal(t, tc.expectedMaxTokens, int(maxTokensFloat))
+			}
+		})
+	}
+}
+
+func TestApplyPatches_GPT5MaxTokensConversion(t *testing.T) {
+	plugin := patch.NewPatchPlugin()
+	config := &patch.Config{}
+
+	testCases := []struct {
+		name                          string
+		input                         map[string]any
+		actualModel                   string
+		expectedMaxCompletionTokens   int
+		shouldHaveMaxTokens           bool
+		shouldModify                  bool
+		shouldHaveMaxCompletionTokens bool
+	}{
+		{
+			name: "gpt-5 model with max_tokens",
+			input: map[string]any{
+				"model":       "gpt-5",
+				"max_tokens":  4000,
+				"temperature": 0.7,
+			},
+			actualModel:                   "gpt-5",
+			expectedMaxCompletionTokens:   4000,
+			shouldHaveMaxTokens:           false,
+			shouldModify:                  true,
+			shouldHaveMaxCompletionTokens: true,
+		},
+		{
+			name: "gpt-5 model without max_tokens",
+			input: map[string]any{
+				"model":       "gpt-5",
+				"temperature": 0.7,
+			},
+			actualModel:                   "gpt-5",
+			shouldHaveMaxTokens:           false,
+			shouldModify:                  true,
+			shouldHaveMaxCompletionTokens: false,
+		},
+		{
+			name: "gpt-4 model with max_tokens",
+			input: map[string]any{
+				"model":      "gpt-4",
+				"max_tokens": 4000,
+			},
+			actualModel:                   "gpt-4",
+			shouldHaveMaxTokens:           true,
+			shouldModify:                  false,
+			shouldHaveMaxCompletionTokens: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			inputBytes, err := sonic.Marshal(tc.input)
+			require.NoError(t, err)
+
+			meta := &meta.Meta{ActualModel: tc.actualModel}
+			outputBytes, modified, err := plugin.ApplyPatches(inputBytes, meta, config)
+			require.NoError(t, err)
+			assert.Equal(t, tc.shouldModify, modified)
+
+			var output map[string]any
+
+			err = sonic.Unmarshal(outputBytes, &output)
+			require.NoError(t, err)
+
+			if tc.shouldHaveMaxCompletionTokens {
+				maxCompletionTokens, ok := output["max_completion_tokens"].(float64)
+				require.True(t, ok, "max_completion_tokens should be float64")
+				assert.Equal(
+					t,
+					tc.expectedMaxCompletionTokens,
+					int(maxCompletionTokens),
+				)
+			} else {
+				_, hasMaxCompletionTokens := output["max_completion_tokens"]
+				assert.False(t, hasMaxCompletionTokens, "max_completion_tokens should not exist")
+			}
+
+			_, hasMaxTokens := output["max_tokens"]
+			assert.Equal(t, tc.shouldHaveMaxTokens, hasMaxTokens)
+		})
+	}
+}
+
+func TestCustomUserPatches(t *testing.T) {
+	plugin := patch.NewPatchPlugin()
+	config := &patch.Config{
+		UserPatches: []patch.PatchRule{
+			{
+				Name: "test_temperature_limit",
+				Conditions: []patch.PatchCondition{
+					{
+						Key:      "model",
+						Operator: patch.OperatorContains,
+						Value:    "test",
+					},
+				},
+				Operations: []patch.PatchOperation{
+					{
+						Op:    patch.OpLimit,
+						Key:   "temperature",
+						Value: 1.0,
+					},
+				},
+			},
+			{
+				Name: "add_default_top_p",
+				Conditions: []patch.PatchCondition{
+					{
+						Key:      "top_p",
+						Operator: patch.OperatorNotExists,
+						Value:    "",
+					},
+				},
+				Operations: []patch.PatchOperation{
+					{
+						Op:    patch.OpAdd,
+						Key:   "top_p",
+						Value: 0.9,
+					},
+				},
+			},
+		},
+	}
+
+	// Test temperature limit
+	input := map[string]any{
+		"model":       "test-model",
+		"temperature": 1.5,
+	}
+	inputBytes, err := sonic.Marshal(input)
+	require.NoError(t, err)
+
+	meta := &meta.Meta{ActualModel: "test-model"}
+	outputBytes, modified, err := plugin.ApplyPatches(inputBytes, meta, config)
+	require.NoError(t, err)
+	assert.True(t, modified)
+
+	var output map[string]any
+
+	err = sonic.Unmarshal(outputBytes, &output)
+	require.NoError(t, err)
+	assert.Equal(t, 1.0, output["temperature"])
+	assert.Equal(t, 0.9, output["top_p"]) // Should be added
+}
+
+func TestNestedFieldOperations(t *testing.T) {
+	plugin := patch.NewPatchPlugin()
+	config := &patch.Config{
+		UserPatches: []patch.PatchRule{
+			{
+				Name: "nested_operations",
+				Operations: []patch.PatchOperation{
+					{
+						Op:    patch.OpSet,
+						Key:   "parameters.max_tokens",
+						Value: 2000,
+					},
+					{
+						Op:    patch.OpSet,
+						Key:   "metadata.version",
+						Value: "1.0",
+					},
+				},
+			},
+		},
+	}
+
+	input := map[string]any{
+		"model": "test",
+		"parameters": map[string]any{
+			"temperature": 0.7,
+		},
+	}
+	inputBytes, err := sonic.Marshal(input)
+	require.NoError(t, err)
+
+	meta := &meta.Meta{ActualModel: "test"}
+	outputBytes, modified, err := plugin.ApplyPatches(inputBytes, meta, config)
+	require.NoError(t, err)
+	assert.True(t, modified)
+
+	var output map[string]any
+
+	err = sonic.Unmarshal(outputBytes, &output)
+	require.NoError(t, err)
+
+	// Check nested field access
+	params, ok := output["parameters"].(map[string]any)
+	require.True(t, ok)
+	maxTokens, ok := params["max_tokens"].(float64)
+	require.True(t, ok, "max_tokens should be float64")
+	assert.Equal(t, 2000, int(maxTokens))
+	assert.Equal(t, 0.7, params["temperature"])
+
+	metadata, ok := output["metadata"].(map[string]any)
+	require.True(t, ok)
+	assert.Equal(t, "1.0", metadata["version"])
+}
+
+func TestPlaceholderResolution(t *testing.T) {
+	plugin := patch.NewPatchPlugin()
+	config := &patch.Config{
+		UserPatches: []patch.PatchRule{
+			{
+				Name: "placeholder_test",
+				Conditions: []patch.PatchCondition{
+					{
+						Key:      "max_tokens",
+						Operator: patch.OperatorExists,
+					},
+				},
+				Operations: []patch.PatchOperation{
+					{
+						Op:    patch.OpSet,
+						Key:   "max_completion_tokens",
+						Value: "{{max_tokens}}",
+					},
+					{
+						Op:  patch.OpDelete,
+						Key: "max_tokens",
+					},
+				},
+			},
+		},
+	}
+
+	input := map[string]any{
+		"model":      "test",
+		"max_tokens": 3000,
+	}
+	inputBytes, err := sonic.Marshal(input)
+	require.NoError(t, err)
+
+	meta := &meta.Meta{ActualModel: "test"}
+	outputBytes, modified, err := plugin.ApplyPatches(inputBytes, meta, config)
+	require.NoError(t, err)
+	assert.True(t, modified)
+
+	var output map[string]any
+
+	err = sonic.Unmarshal(outputBytes, &output)
+	require.NoError(t, err)
+
+	maxCompletionTokens, ok := output["max_completion_tokens"].(float64)
+	require.True(t, ok, "max_completion_tokens should be float64")
+	assert.Equal(t, 3000, int(maxCompletionTokens))
+
+	_, hasMaxTokens := output["max_tokens"]
+	assert.False(t, hasMaxTokens)
+}
+
+func TestOperators(t *testing.T) {
+	plugin := patch.NewPatchPlugin()
+	config := &patch.Config{
+		UserPatches: []patch.PatchRule{
+			{
+				Name: "operator_tests",
+				Conditions: []patch.PatchCondition{
+					{
+						Key:      "model",
+						Operator: patch.OperatorRegex,
+						Value:    "^gpt-[0-9]$",
+					},
+				},
+				Operations: []patch.PatchOperation{
+					{
+						Op:    patch.OpSet,
+						Key:   "matched",
+						Value: true,
+					},
+				},
+			},
+		},
+	}
+
+	testCases := []struct {
+		model       string
+		shouldMatch bool
+	}{
+		{"gpt-4", true},
+		{"gpt-3", true},
+		{"gpt-4o", false},
+		{"claude-3", false},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.model, func(t *testing.T) {
+			input := map[string]any{"model": tc.model}
+			inputBytes, err := sonic.Marshal(input)
+			require.NoError(t, err)
+
+			meta := &meta.Meta{ActualModel: tc.model}
+			outputBytes, modified, err := plugin.ApplyPatches(inputBytes, meta, config)
+			require.NoError(t, err)
+			assert.Equal(t, tc.shouldMatch, modified)
+
+			if tc.shouldMatch {
+				var output map[string]any
+
+				err = sonic.Unmarshal(outputBytes, &output)
+				require.NoError(t, err)
+
+				matched, ok := output["matched"].(bool)
+				require.True(t, ok, "matched should be bool")
+				assert.True(t, matched)
+			}
+		})
+	}
+}
+
+func TestInvalidJSON(t *testing.T) {
+	plugin := patch.NewPatchPlugin()
+	config := &patch.Config{}
+
+	invalidJSON := []byte(`{"invalid": json}`)
+	meta := &meta.Meta{ActualModel: "test"}
+
+	outputBytes, modified, err := plugin.ApplyPatches(invalidJSON, meta, config)
+	require.NoError(t, err)
+	assert.False(t, modified)
+	assert.Equal(t, invalidJSON, outputBytes)
+}
+
+func TestConvertRequest(t *testing.T) {
+	// Skip this test since it requires database initialization
+	// The functionality is already tested in other unit tests
+	t.Skip("Skipping integration test - requires database setup")
+}
+
+func TestToFloat64(t *testing.T) {
+	testCases := []struct {
+		input    any
+		expected float64
+		hasError bool
+	}{
+		{float64(3.14), 3.14, false},
+		{float32(2.5), 2.5, false},
+		{int(42), 42.0, false},
+		{int32(100), 100.0, false},
+		{int64(200), 200.0, false},
+		{"123.45", 123.45, false},
+		{"invalid", 0, true},
+		{true, 0, true},
+	}
+
+	for _, tc := range testCases {
+		result, err := patch.ToFloat64(tc.input)
+		if tc.hasError {
+			assert.Error(t, err)
+		} else {
+			assert.NoError(t, err)
+			assert.Equal(t, tc.expected, result)
+		}
+	}
+}
+
+func TestConditionLogicOperators(t *testing.T) {
+	plugin := patch.NewPatchPlugin()
+
+	testCases := []struct {
+		name         string
+		config       *patch.Config
+		input        map[string]any
+		actualModel  string
+		shouldModify bool
+	}{
+		{
+			name: "OR logic - one condition matches",
+			config: &patch.Config{
+				UserPatches: []patch.PatchRule{
+					{
+						Name:           "or_logic_test",
+						ConditionLogic: patch.LogicOr,
+						Conditions: []patch.PatchCondition{
+							{
+								Key:      "model",
+								Operator: patch.OperatorEquals,
+								Value:    "gpt-4",
+							},
+							{
+								Key:      "temperature",
+								Operator: patch.OperatorGreaterThan,
+								Value:    "1.5",
+							},
+						},
+						Operations: []patch.PatchOperation{
+							{
+								Op:    patch.OpSet,
+								Key:   "modified",
+								Value: true,
+							},
+						},
+					},
+				},
+			},
+			input: map[string]any{
+				"model":       "claude-3",
+				"temperature": 2.0,
+			},
+			actualModel:  "claude-3",
+			shouldModify: true,
+		},
+		{
+			name: "OR logic - no condition matches",
+			config: &patch.Config{
+				UserPatches: []patch.PatchRule{
+					{
+						Name:           "or_logic_test_no_match",
+						ConditionLogic: patch.LogicOr,
+						Conditions: []patch.PatchCondition{
+							{
+								Key:      "model",
+								Operator: patch.OperatorEquals,
+								Value:    "gpt-4",
+							},
+							{
+								Key:      "temperature",
+								Operator: patch.OperatorGreaterThan,
+								Value:    "1.5",
+							},
+						},
+						Operations: []patch.PatchOperation{
+							{
+								Op:    patch.OpSet,
+								Key:   "modified",
+								Value: true,
+							},
+						},
+					},
+				},
+			},
+			input: map[string]any{
+				"model":       "claude-3",
+				"temperature": 1.0,
+			},
+			actualModel:  "claude-3",
+			shouldModify: false,
+		},
+		{
+			name: "AND logic (default) - all conditions match",
+			config: &patch.Config{
+				UserPatches: []patch.PatchRule{
+					{
+						Name: "and_logic_test",
+						Conditions: []patch.PatchCondition{
+							{
+								Key:      "model",
+								Operator: patch.OperatorContains,
+								Value:    "gpt",
+							},
+							{
+								Key:      "temperature",
+								Operator: patch.OperatorLessThan,
+								Value:    "1.5",
+							},
+						},
+						Operations: []patch.PatchOperation{
+							{
+								Op:    patch.OpSet,
+								Key:   "modified",
+								Value: true,
+							},
+						},
+					},
+				},
+			},
+			input: map[string]any{
+				"model":       "gpt-4",
+				"temperature": 1.0,
+			},
+			actualModel:  "gpt-4",
+			shouldModify: true,
+		},
+		{
+			name: "AND logic (default) - one condition fails",
+			config: &patch.Config{
+				UserPatches: []patch.PatchRule{
+					{
+						Name: "and_logic_test_fail",
+						Conditions: []patch.PatchCondition{
+							{
+								Key:      "model",
+								Operator: patch.OperatorContains,
+								Value:    "gpt",
+							},
+							{
+								Key:      "temperature",
+								Operator: patch.OperatorLessThan,
+								Value:    "1.5",
+							},
+						},
+						Operations: []patch.PatchOperation{
+							{
+								Op:    patch.OpSet,
+								Key:   "modified",
+								Value: true,
+							},
+						},
+					},
+				},
+			},
+			input: map[string]any{
+				"model":       "gpt-4",
+				"temperature": 2.0,
+			},
+			actualModel:  "gpt-4",
+			shouldModify: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			inputBytes, err := sonic.Marshal(tc.input)
+			require.NoError(t, err)
+
+			meta := &meta.Meta{ActualModel: tc.actualModel}
+			outputBytes, modified, err := plugin.ApplyPatches(inputBytes, meta, tc.config)
+			require.NoError(t, err)
+			assert.Equal(t, tc.shouldModify, modified)
+
+			if tc.shouldModify {
+				var output map[string]any
+
+				err = sonic.Unmarshal(outputBytes, &output)
+				require.NoError(t, err)
+				assert.Equal(t, output["modified"], true)
+			}
+		})
+	}
+}
+
+func TestConditionNegation(t *testing.T) {
+	plugin := patch.NewPatchPlugin()
+
+	testCases := []struct {
+		name         string
+		config       *patch.Config
+		input        map[string]any
+		actualModel  string
+		shouldModify bool
+	}{
+		{
+			name: "negate condition - should match when negated",
+			config: &patch.Config{
+				UserPatches: []patch.PatchRule{
+					{
+						Name: "negate_test",
+						Conditions: []patch.PatchCondition{
+							{
+								Key:      "model",
+								Operator: patch.OperatorEquals,
+								Value:    "gpt-4",
+								Negate:   true,
+							},
+						},
+						Operations: []patch.PatchOperation{
+							{
+								Op:    patch.OpSet,
+								Key:   "modified",
+								Value: true,
+							},
+						},
+					},
+				},
+			},
+			input: map[string]any{
+				"model": "claude-3",
+			},
+			actualModel:  "claude-3",
+			shouldModify: true,
+		},
+		{
+			name: "negate condition - should not match when negated",
+			config: &patch.Config{
+				UserPatches: []patch.PatchRule{
+					{
+						Name: "negate_test_no_match",
+						Conditions: []patch.PatchCondition{
+							{
+								Key:      "model",
+								Operator: patch.OperatorEquals,
+								Value:    "gpt-4",
+								Negate:   true,
+							},
+						},
+						Operations: []patch.PatchOperation{
+							{
+								Op:    patch.OpSet,
+								Key:   "modified",
+								Value: true,
+							},
+						},
+					},
+				},
+			},
+			input: map[string]any{
+				"model": "gpt-4",
+			},
+			actualModel:  "gpt-4",
+			shouldModify: false,
+		},
+		{
+			name: "OR with negation - complex logic",
+			config: &patch.Config{
+				UserPatches: []patch.PatchRule{
+					{
+						Name:           "or_with_negate",
+						ConditionLogic: patch.LogicOr,
+						Conditions: []patch.PatchCondition{
+							{
+								Key:      "model",
+								Operator: patch.OperatorEquals,
+								Value:    "gpt-4",
+							},
+							{
+								Key:      "temperature",
+								Operator: patch.OperatorExists,
+								Negate:   true, // NOT exists
+							},
+						},
+						Operations: []patch.PatchOperation{
+							{
+								Op:    patch.OpSet,
+								Key:   "modified",
+								Value: true,
+							},
+						},
+					},
+				},
+			},
+			input: map[string]any{
+				"model": "claude-3",
+				// no temperature field
+			},
+			actualModel:  "claude-3",
+			shouldModify: true, // Should match because temperature doesn't exist (negated exists)
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			inputBytes, err := sonic.Marshal(tc.input)
+			require.NoError(t, err)
+
+			meta := &meta.Meta{ActualModel: tc.actualModel}
+			outputBytes, modified, err := plugin.ApplyPatches(inputBytes, meta, tc.config)
+			require.NoError(t, err)
+			assert.Equal(t, tc.shouldModify, modified)
+
+			if tc.shouldModify {
+				var output map[string]any
+
+				err = sonic.Unmarshal(outputBytes, &output)
+				require.NoError(t, err)
+				assert.Equal(t, output["modified"], true)
+			}
+		})
+	}
+}

core/relay/plugin/streamfake/fake.go

@@ -20,6 +20,7 @@ import (
 	relaymodel "github.com/labring/aiproxy/core/relay/model"
 	"github.com/labring/aiproxy/core/relay/plugin"
 	"github.com/labring/aiproxy/core/relay/plugin/noop"
+	"github.com/labring/aiproxy/core/relay/plugin/patch"
 )
 
 var _ plugin.Plugin = (*StreamFake)(nil)
@@ -83,22 +84,16 @@ func (p *StreamFake) ConvertRequest(
 		return do.ConvertRequest(meta, store, req)
 	}
 
-	// Modify request to enable streaming
-	_, err = node.Set("stream", ast.NewBool(true))
-	if err != nil {
-		return do.ConvertRequest(meta, store, req)
-	}
-
-	// Create new request body
-	modifiedBody, err := node.MarshalJSON()
-	if err != nil {
-		return do.ConvertRequest(meta, store, req)
-	}
-
-	// Update the request
-	common.SetRequestBody(req, modifiedBody)
-	defer common.SetRequestBody(req, body)
-
+	patch.AddLazyPatch(meta, patch.PatchOperation{
+		Op: patch.OpFunction,
+		Function: func(root *ast.Node) (bool, error) {
+			_, err := root.Set("stream", ast.NewBool(true))
+			if err != nil {
+				return false, err
+			}
+			return true, nil
+		},
+	})
 	meta.Set(fakeStreamKey, true)
 
 	return do.ConvertRequest(meta, store, req)

mcp-servers/.golangci.yml

@@ -1,7 +1,7 @@
 version: "2"
 
 run:
-  go: "1.24"
+  go: "1.25.0"
   relative-path-mode: gomod
   modules-download-mode: readonly
 

openapi-mcp/.golangci.yml

@@ -1,7 +1,7 @@
 version: "2"
 
 run:
-  go: "1.24"
+  go: "1.25.0"
   relative-path-mode: gomod
   modules-download-mode: readonly