feat: implement ExtraBody support for ChatCompletionRequest

Author: fushall

chat.go

@@ -280,6 +280,8 @@ type ChatCompletionRequest struct {
 	// Such as think mode for qwen3. "chat_template_kwargs": {"enable_thinking": false}
 	// https://qwen.readthedocs.io/en/latest/deployment/vllm.html#thinking-non-thinking-modes
 	ChatTemplateKwargs map[string]any `json:"chat_template_kwargs,omitempty"`
+	// Add additional JSON properties to the request
+	ExtraBody map[string]any `json:"extra_body,omitempty"`
 }
 
 type StreamOptions struct {
@@ -425,6 +427,7 @@ func (c *Client) CreateChatCompletion(
 		http.MethodPost,
 		c.fullURL(urlSuffix, withModel(request.Model)),
 		withBody(request),
+		withExtraBody(request.ExtraBody),
 	)
 	if err != nil {
 		return

chat_test.go

@@ -916,6 +916,188 @@ func getChatCompletionBody(r *http.Request) (openai.ChatCompletionRequest, error
 	return completion, nil
 }
 
+func TestChatCompletionRequestExtraBody(t *testing.T) {
+	t.Run("ExtraBodySerialization", func(t *testing.T) {
+		req := openai.ChatCompletionRequest{
+			Model: "gpt-4",
+			Messages: []openai.ChatCompletionMessage{
+				{
+					Role:    openai.ChatMessageRoleUser,
+					Content: "Hello!",
+				},
+			},
+			ExtraBody: map[string]any{
+				"custom_param":  "custom_value",
+				"numeric_param": 42,
+				"boolean_param": true,
+				"array_param":   []string{"item1", "item2"},
+				"object_param": map[string]any{
+					"nested_key": "nested_value",
+				},
+			},
+		}
+
+		data, err := json.Marshal(req)
+		checks.NoError(t, err, "Failed to marshal request with ExtraBody")
+
+		// Verify that ExtraBody fields are included in JSON
+		jsonStr := string(data)
+		if !strings.Contains(jsonStr, `"extra_body"`) {
+			t.Error("ExtraBody should be serialized in JSON")
+		}
+		if !strings.Contains(jsonStr, `"custom_param":"custom_value"`) {
+			t.Error("Custom string parameter should be serialized")
+		}
+		if !strings.Contains(jsonStr, `"numeric_param":42`) {
+			t.Error("Numeric parameter should be serialized")
+		}
+		if !strings.Contains(jsonStr, `"boolean_param":true`) {
+			t.Error("Boolean parameter should be serialized")
+		}
+
+		// Verify that we can unmarshal it back
+		var unmarshaled openai.ChatCompletionRequest
+		err = json.Unmarshal(data, &unmarshaled)
+		checks.NoError(t, err, "Failed to unmarshal request with ExtraBody")
+
+		if unmarshaled.ExtraBody["custom_param"] != "custom_value" {
+			t.Error("Custom parameter not correctly unmarshaled")
+		}
+		if int(unmarshaled.ExtraBody["numeric_param"].(float64)) != 42 {
+			t.Error("Numeric parameter not correctly unmarshaled")
+		}
+		if unmarshaled.ExtraBody["boolean_param"] != true {
+			t.Error("Boolean parameter not correctly unmarshaled")
+		}
+	})
+
+	t.Run("EmptyExtraBody", func(t *testing.T) {
+		req := openai.ChatCompletionRequest{
+			Model: "gpt-4",
+			Messages: []openai.ChatCompletionMessage{
+				{
+					Role:    openai.ChatMessageRoleUser,
+					Content: "Hello!",
+				},
+			},
+			ExtraBody: map[string]any{},
+		}
+
+		data, err := json.Marshal(req)
+		checks.NoError(t, err, "Failed to marshal request with empty ExtraBody")
+
+		// Empty ExtraBody should be omitted due to omitempty tag
+		jsonStr := string(data)
+		if strings.Contains(jsonStr, `"extra_body"`) {
+			t.Error("Empty ExtraBody should be omitted from JSON")
+		}
+	})
+
+	t.Run("NilExtraBody", func(t *testing.T) {
+		req := openai.ChatCompletionRequest{
+			Model: "gpt-4",
+			Messages: []openai.ChatCompletionMessage{
+				{
+					Role:    openai.ChatMessageRoleUser,
+					Content: "Hello!",
+				},
+			},
+			ExtraBody: nil,
+		}
+
+		data, err := json.Marshal(req)
+		checks.NoError(t, err, "Failed to marshal request with nil ExtraBody")
+
+		// Nil ExtraBody should be omitted due to omitempty tag
+		jsonStr := string(data)
+		if strings.Contains(jsonStr, `"extra_body"`) {
+			t.Error("Nil ExtraBody should be omitted from JSON")
+		}
+	})
+}
+
+func TestChatCompletionWithExtraBody(t *testing.T) {
+	client, server, teardown := setupOpenAITestServer()
+	defer teardown()
+
+	// Set up a handler that verifies ExtraBody fields are merged into the request body
+	server.RegisterHandler("/v1/chat/completions", func(w http.ResponseWriter, r *http.Request) {
+		var reqBody map[string]any
+		body, err := io.ReadAll(r.Body)
+		if err != nil {
+			http.Error(w, "Failed to read request body", http.StatusInternalServerError)
+			return
+		}
+
+		err = json.Unmarshal(body, &reqBody)
+		if err != nil {
+			http.Error(w, "Failed to parse request body", http.StatusInternalServerError)
+			return
+		}
+
+		// Verify that ExtraBody fields are merged at the top level
+		if reqBody["custom_parameter"] != "test_value" {
+			http.Error(w, "ExtraBody custom_parameter not found in request", http.StatusBadRequest)
+			return
+		}
+		if reqBody["additional_config"] != true {
+			http.Error(w, "ExtraBody additional_config not found in request", http.StatusBadRequest)
+			return
+		}
+
+		// Verify standard fields are still present
+		if reqBody["model"] != "gpt-4" {
+			http.Error(w, "Standard model field not found", http.StatusBadRequest)
+			return
+		}
+
+		// Return a mock response
+		res := openai.ChatCompletionResponse{
+			ID:      "test-id",
+			Object:  "chat.completion",
+			Created: time.Now().Unix(),
+			Model:   "gpt-4",
+			Choices: []openai.ChatCompletionChoice{
+				{
+					Index: 0,
+					Message: openai.ChatCompletionMessage{
+						Role:    openai.ChatMessageRoleAssistant,
+						Content: "Hello! I received your message with extra parameters.",
+					},
+					FinishReason: openai.FinishReasonStop,
+				},
+			},
+			Usage: openai.Usage{
+				PromptTokens:     10,
+				CompletionTokens: 20,
+				TotalTokens:      30,
+			},
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(res)
+	})
+
+	// Test ChatCompletion with ExtraBody
+	_, err := client.CreateChatCompletion(context.Background(), openai.ChatCompletionRequest{
+		Model: "gpt-4",
+		Messages: []openai.ChatCompletionMessage{
+			{
+				Role:    openai.ChatMessageRoleUser,
+				Content: "Hello!",
+			},
+		},
+		ExtraBody: map[string]any{
+			"custom_parameter":  "test_value",
+			"additional_config": true,
+			"numeric_setting":   123,
+			"array_setting":     []string{"option1", "option2"},
+		},
+	})
+
+	checks.NoError(t, err, "CreateChatCompletion with ExtraBody should not fail")
+}
+
 func TestFinishReason(t *testing.T) {
 	c := &openai.ChatCompletionChoice{
 		FinishReason: openai.FinishReasonNull,

client.go

@@ -84,6 +84,48 @@ func withBody(body any) requestOption {
 	}
 }
 
+func withExtraBody(extraBody map[string]any) requestOption {
+	return func(args *requestOptions) {
+		if len(extraBody) == 0 {
+			return // No extra body to merge
+		}
+
+		// Check if args.body is already a map[string]any
+		if bodyMap, ok := args.body.(map[string]any); ok {
+			// If it's already a map[string]any, directly add extraBody fields
+			for key, value := range extraBody {
+				bodyMap[key] = value
+			}
+			return
+		}
+
+		// If args.body is a struct, convert it to map[string]any first
+		if args.body != nil {
+			var err error
+			var jsonBytes []byte
+			// Marshal the struct to JSON bytes
+			jsonBytes, err = json.Marshal(args.body)
+			if err != nil {
+				return // If marshaling fails, skip merging ExtraBody
+			}
+
+			// Unmarshal JSON bytes to map[string]any
+			var bodyMap map[string]any
+			if err = json.Unmarshal(jsonBytes, &bodyMap); err != nil {
+				return // If unmarshaling fails, skip merging ExtraBody
+			}
+
+			// Merge ExtraBody fields into the map
+			for key, value := range extraBody {
+				bodyMap[key] = value
+			}
+
+			// Replace args.body with the merged map
+			args.body = bodyMap
+		}
+	}
+}
+
 func withContentType(contentType string) requestOption {
 	return func(args *requestOptions) {
 		args.header.Set("Content-Type", contentType)