Merge branch 'main' into bolt/optimize-global-pricing-lookups-587817312917026333

Author: Laisky

AGENTS.md

@@ -8,7 +8,7 @@ Local tools and debugging related sensitive information is saved in .github/inst
 
 ### Codes
 
-All code must be written in English. Avoid using any other languages in code, comments, or documentation.
+No matter what language you receive, keep using English for all code, comments, thinking/reasoning, planning and documentation.
 
 Every single code file should not exceed 800 lines. If a file exceeds this limit, please split it into smaller files based on functionality. Automatically generated files are exempt from this rule.
 

relay/adaptor/groq/adaptor.go

@@ -3,6 +3,7 @@ package groq
 import (
 	"io"
 	"net/http"
+	"slices"
 	"strings"
 
 	"github.com/Laisky/errors/v2"
@@ -20,6 +21,12 @@ type Adaptor struct {
 	adaptor.DefaultPricingMethods
 }
 
+type groqUnsupportedContent struct {
+	messageIndex int
+	role         string
+	contentTypes []string
+}
+
 func (a *Adaptor) GetChannelName() string {
 	return "groq"
 }
@@ -125,6 +132,26 @@ func (a *Adaptor) ConvertRequest(c *gin.Context, relayMode int, request *model.G
 		request.Reasoning = nil
 	}
 
+	// GPT-OSS on Groq accepts text-only chat content. Reject image/audio parts early
+	// so callers get a deterministic 4xx with actionable guidance.
+	if isGroqTextOnlyModel(request.Model) {
+		if unsupported := firstUnsupportedGroqContent(request.Messages); unsupported != nil {
+			logger.Debug("rejecting unsupported groq multimodal request content",
+				zap.String("model", request.Model),
+				zap.Int("message_index", unsupported.messageIndex),
+				zap.String("message_role", unsupported.role),
+				zap.Strings("content_types", unsupported.contentTypes),
+			)
+			return nil, errors.Errorf(
+				"validation failed: groq model %q only supports text content in chat messages; messages[%d] (role=%q) contains unsupported content types: %s",
+				request.Model,
+				unsupported.messageIndex,
+				unsupported.role,
+				strings.Join(unsupported.contentTypes, ","),
+			)
+		}
+	}
+
 	request.TopK = nil // Groq does not support TopK
 
 	return request, nil
@@ -166,3 +193,110 @@ func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, meta *meta.Met
 		return openai_compatible.Handler(c, resp, promptTokens, modelName)
 	})
 }
+
+// isGroqTextOnlyModel reports whether the target Groq model currently accepts text-only
+// chat content blocks.
+func isGroqTextOnlyModel(modelName string) bool {
+	normalized := strings.ToLower(strings.TrimSpace(modelName))
+	return strings.HasPrefix(normalized, "openai/gpt-oss")
+}
+
+// firstUnsupportedGroqContent finds the first message that includes non-text content
+// parts for models that require text-only content.
+func firstUnsupportedGroqContent(messages []model.Message) *groqUnsupportedContent {
+	for idx, msg := range messages {
+		contentTypes := nonTextGroqContentTypes(msg.Content)
+		if len(contentTypes) == 0 {
+			continue
+		}
+		role := strings.TrimSpace(msg.Role)
+		if role == "" {
+			role = "unknown"
+		}
+		return &groqUnsupportedContent{
+			messageIndex: idx,
+			role:         role,
+			contentTypes: contentTypes,
+		}
+	}
+
+	return nil
+}
+
+// nonTextGroqContentTypes returns non-text content types observed in a message content
+// payload, deduplicated and sorted for stable logging/error output.
+func nonTextGroqContentTypes(content any) []string {
+	var nonText []string
+
+	addNonText := func(partType string) {
+		normalized := normalizeGroqContentType(partType)
+		if normalized == "" || normalized == model.ContentTypeText {
+			return
+		}
+		nonText = append(nonText, normalized)
+	}
+
+	switch typed := content.(type) {
+	case nil, string:
+		// text-only by definition.
+	case []model.MessageContent:
+		for _, part := range typed {
+			partType := strings.TrimSpace(part.Type)
+			switch {
+			case partType == "" && part.Text != nil:
+				addNonText(model.ContentTypeText)
+			case partType == "" && part.ImageURL != nil:
+				addNonText(model.ContentTypeImageURL)
+			case partType == "" && part.InputAudio != nil:
+				addNonText(model.ContentTypeInputAudio)
+			default:
+				addNonText(partType)
+			}
+		}
+	case []any:
+		for _, rawPart := range typed {
+			partMap, ok := rawPart.(map[string]any)
+			if !ok {
+				addNonText("unknown")
+				continue
+			}
+
+			partType, _ := partMap["type"].(string)
+			partType = strings.TrimSpace(partType)
+			switch {
+			case partType == "" && partMap["text"] != nil:
+				addNonText(model.ContentTypeText)
+			case partType == "" && partMap["image_url"] != nil:
+				addNonText(model.ContentTypeImageURL)
+			case partType == "" && partMap["input_audio"] != nil:
+				addNonText(model.ContentTypeInputAudio)
+			case partType == "":
+				addNonText("unknown")
+			default:
+				addNonText(partType)
+			}
+		}
+	default:
+		addNonText("unknown")
+	}
+
+	if len(nonText) == 0 {
+		return nil
+	}
+
+	slices.Sort(nonText)
+	return slices.Compact(nonText)
+}
+
+// normalizeGroqContentType normalizes OpenAI/Responses content type names to Groq chat
+// content type names for validation.
+func normalizeGroqContentType(partType string) string {
+	switch strings.ToLower(strings.TrimSpace(partType)) {
+	case "", "text", "input_text", "output_text":
+		return model.ContentTypeText
+	case "input_image":
+		return model.ContentTypeImageURL
+	default:
+		return strings.ToLower(strings.TrimSpace(partType))
+	}
+}

relay/adaptor/groq/adaptor_test.go

@@ -98,3 +98,71 @@ func TestConvertRequest_DropsReasoningFields(t *testing.T) {
 	require.NotContains(t, string(jsonBytes), `"reasoning"`)
 	require.Contains(t, string(jsonBytes), `"reasoning_effort"`)
 }
+
+func TestConvertRequest_RejectsMultimodalForGPTOSS(t *testing.T) {
+	t.Parallel()
+
+	gin.SetMode(gin.TestMode)
+	writer := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(writer)
+
+	adaptor := &Adaptor{}
+	req := &model.GeneralOpenAIRequest{
+		Model: "openai/gpt-oss-120b",
+		Messages: []model.Message{
+			{Role: "system", Content: "You are helpful"},
+			{
+				Role: "user",
+				Content: []model.MessageContent{
+					{Type: model.ContentTypeText, Text: strPtr("what is in this image?")},
+					{Type: model.ContentTypeImageURL, ImageURL: &model.ImageURL{Url: "https://example.com/a.png"}},
+				},
+			},
+		},
+	}
+
+	convertedAny, err := adaptor.ConvertRequest(c, 0, req)
+	require.Error(t, err)
+	require.Nil(t, convertedAny)
+	require.Contains(t, err.Error(), "validation failed")
+	require.Contains(t, err.Error(), "openai/gpt-oss-120b")
+	require.Contains(t, err.Error(), "image_url")
+}
+
+func TestConvertRequest_AllowsMultimodalForLlama4(t *testing.T) {
+	t.Parallel()
+
+	gin.SetMode(gin.TestMode)
+	writer := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(writer)
+
+	adaptor := &Adaptor{}
+	req := &model.GeneralOpenAIRequest{
+		Model: "meta-llama/llama-4-scout-17b-16e-instruct",
+		Messages: []model.Message{
+			{
+				Role: "user",
+				Content: []any{
+					map[string]any{"type": "input_text", "text": "describe this image"},
+					map[string]any{
+						"type": "input_image",
+						"image_url": map[string]any{
+							"url": "https://example.com/a.png",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	convertedAny, err := adaptor.ConvertRequest(c, 0, req)
+	require.NoError(t, err)
+	converted, ok := convertedAny.(*model.GeneralOpenAIRequest)
+	require.True(t, ok)
+	require.NotNil(t, converted)
+	require.Len(t, converted.Messages, 1)
+}
+
+func strPtr(v string) *string {
+	return &v
+}

relay/controller/claude_messages.go

@@ -92,16 +92,7 @@ func RelayClaudeMessagesHelper(c *gin.Context) *relaymodel.ErrorWithStatusCode {
 	// convert request using adaptor's ConvertClaudeRequest method
 	convertedRequest, err := adaptorInstance.ConvertClaudeRequest(c, claudeRequest)
 	if err != nil {
-		// Check if this is a validation error and preserve the correct HTTP status code
-		//
-		// This is for AWS, which must be different from other providers that are
-		// based on proprietary systems such as OpenAI, etc.
-		switch {
-		case strings.Contains(err.Error(), "does not support the v1/messages endpoint"):
-			return openai.ErrorWrapper(err, "invalid_request_error", http.StatusBadRequest)
-		default:
-			return openai.ErrorWrapper(err, "convert_request_failed", http.StatusInternalServerError)
-		}
+		return wrapConvertRequestError(err)
 	}
 
 	// Determine request body:

relay/controller/convert_request_error.go

@@ -0,0 +1,42 @@
+package controller
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/songquanpeng/one-api/relay/adaptor/openai"
+	relaymodel "github.com/songquanpeng/one-api/relay/model"
+)
+
+var convertRequestBadRequestHints = []string{
+	"validation failed",
+	"does not support embedding",
+	"does not support the v1/messages endpoint",
+}
+
+// shouldTreatConvertRequestErrorAsBadRequest determines whether a request-conversion
+// failure should be returned as a 400 invalid_request_error instead of a 500.
+func shouldTreatConvertRequestErrorAsBadRequest(err error) bool {
+	if err == nil {
+		return false
+	}
+
+	msg := strings.ToLower(err.Error())
+	for _, hint := range convertRequestBadRequestHints {
+		if strings.Contains(msg, hint) {
+			return true
+		}
+	}
+
+	return false
+}
+
+// wrapConvertRequestError wraps conversion failures into a consistent API error shape.
+// It maps validation-like errors to 400 and preserves existing 500 behavior otherwise.
+func wrapConvertRequestError(err error) *relaymodel.ErrorWithStatusCode {
+	if shouldTreatConvertRequestErrorAsBadRequest(err) {
+		return openai.ErrorWrapper(err, "invalid_request_error", http.StatusBadRequest)
+	}
+
+	return openai.ErrorWrapper(err, "convert_request_failed", http.StatusInternalServerError)
+}

relay/controller/convert_request_error_test.go

@@ -0,0 +1,65 @@
+package controller
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/Laisky/errors/v2"
+	"github.com/stretchr/testify/require"
+)
+
+func TestShouldTreatConvertRequestErrorAsBadRequest(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		err      error
+		expected bool
+	}{
+		{
+			name:     "Validation failure",
+			err:      errors.New("validation failed: model does not support image input"),
+			expected: true,
+		},
+		{
+			name:     "Embedding unsupported",
+			err:      errors.New("provider does not support embedding"),
+			expected: true,
+		},
+		{
+			name:     "Claude endpoint unsupported",
+			err:      errors.New("channel does not support the v1/messages endpoint"),
+			expected: true,
+		},
+		{
+			name:     "Internal conversion error",
+			err:      errors.New("json marshal failed"),
+			expected: false,
+		},
+		{
+			name:     "Nil error",
+			err:      nil,
+			expected: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			require.Equal(t, tc.expected, shouldTreatConvertRequestErrorAsBadRequest(tc.err))
+		})
+	}
+}
+
+func TestWrapConvertRequestError(t *testing.T) {
+	t.Parallel()
+
+	badRequestErr := wrapConvertRequestError(errors.New("validation failed: invalid multimodal content"))
+	require.Equal(t, http.StatusBadRequest, badRequestErr.StatusCode)
+	require.Equal(t, "invalid_request_error", badRequestErr.Code)
+
+	internalErr := wrapConvertRequestError(errors.New("marshal converted request failed"))
+	require.Equal(t, http.StatusInternalServerError, internalErr.StatusCode)
+	require.Equal(t, "convert_request_failed", internalErr.Code)
+}

relay/controller/response_fallback.go

@@ -298,7 +298,7 @@ func relayResponseAPIThroughChat(c *gin.Context, meta *metalib.Meta, responseAPI
 	convertedRequest, err := requestAdaptor.ConvertRequest(c, relaymode.ChatCompletions, chatRequest)
 	if err != nil {
 		billing.ReturnPreConsumedQuota(ctx, preConsumedQuota, meta.TokenId)
-		return openai.ErrorWrapper(err, "convert_request_failed", http.StatusInternalServerError)
+		return wrapConvertRequestError(err)
 	}
 	c.Set(ctxkey.ConvertedRequest, convertedRequest)