v1.0.4-preview.1

Author: CSCITech

model/log.go

@@ -247,7 +247,7 @@ func logOtherRetryMarkers(other string) (errorRetry bool, emptyRetry bool) {
 		return false, false
 	}
 	if marker, ok := otherMap["empty_retry"].(bool); ok && marker {
-		return false, true
+		emptyRetry = true
 	}
 	if retryLog, ok := otherMap["retry_log"].(bool); ok && retryLog {
 		errorRetry = true

model/log_test.go

@@ -84,9 +84,9 @@ func TestGetAllLogsRetrySubtypeFilters(t *testing.T) {
 
 	errorLogs, total, err := GetAllLogs(LogTypeUnknown, LogFilterErrorRetry, 0, 0, "", "", "", 0, 10, 0, "", "", "")
 	require.NoError(t, err)
-	require.EqualValues(t, 3, total)
-	require.Len(t, errorLogs, 3)
-	require.ElementsMatch(t, []int{logs[0].Id, logs[4].Id, logs[5].Id}, []int{errorLogs[0].Id, errorLogs[1].Id, errorLogs[2].Id})
+	require.EqualValues(t, 4, total)
+	require.Len(t, errorLogs, 4)
+	require.ElementsMatch(t, []int{logs[0].Id, logs[4].Id, logs[5].Id, logs[6].Id}, []int{errorLogs[0].Id, errorLogs[1].Id, errorLogs[2].Id, errorLogs[3].Id})
 
 	emptyLogs, total, err := GetAllLogs(LogTypeUnknown, LogFilterEmptyRetry, 0, 0, "", "", "", 0, 10, 0, "", "", "")
 	require.NoError(t, err)
@@ -105,9 +105,9 @@ func TestSumUsedQuotaRetrySubtypeFilters(t *testing.T) {
 
 	errorStat, err := SumUsedQuota(LogTypeUnknown, LogFilterErrorRetry, 0, 0, "", "", "", 0, "")
 	require.NoError(t, err)
-	require.Equal(t, 1000, errorStat.Quota)
-	require.Equal(t, 3, errorStat.Rpm)
-	require.Equal(t, 56, errorStat.Tpm)
+	require.Equal(t, 1350, errorStat.Quota)
+	require.Equal(t, 4, errorStat.Rpm)
+	require.Equal(t, 81, errorStat.Tpm)
 
 	emptyStat, err := SumUsedQuota(LogTypeUnknown, LogFilterEmptyRetry, 0, 0, "", "", "", 0, "")
 	require.NoError(t, err)

relay/channel/gemini/adaptor_responses.go

@@ -1,6 +1,7 @@
 package gemini
 
 import (
+	"fmt"
 	"strings"
 
 	"github.com/MAX-API-Next/MAX-API/common"
@@ -41,8 +42,9 @@ func filterGeminiResponsesTools(raw []byte) ([]byte, error) {
 
 	filtered := make([]map[string]any, 0, len(tools))
 	for _, tool := range tools {
-		if strings.TrimSpace(common.Interface2String(tool["type"])) != "function" {
-			continue
+		toolType := strings.TrimSpace(common.Interface2String(tool["type"]))
+		if toolType != "function" {
+			return nil, fmt.Errorf("gemini responses conversion does not support tool type %q", toolType)
 		}
 		filtered = append(filtered, tool)
 	}

relay/channel/gemini/adaptor_responses_test.go

@@ -1,6 +1,7 @@
 package gemini
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/MAX-API-Next/MAX-API/common"
@@ -58,12 +59,18 @@ func TestConvertOpenAIResponsesRequestToGeminiSkipsCustomToolCalls(t *testing.T)
 			},
 		}),
 		Tools: mustGeminiRawMessage(t, []map[string]any{
-			{"type": "custom", "name": "apply_patch"},
-			{"type": "unknown", "name": "unknown"},
+			{
+				"type":        "function",
+				"name":        "lookup",
+				"description": "Lookup data",
+				"parameters": map[string]any{
+					"type": "object",
+				},
+			},
 		}),
 	})
 
-	assert.Empty(t, got.GetTools())
+	require.Len(t, got.GetTools(), 1)
 	require.Len(t, got.Contents, 2)
 	assert.Equal(t, "model", got.Contents[0].Role)
 	require.Len(t, got.Contents[0].Parts, 1)
@@ -76,19 +83,43 @@ func TestConvertOpenAIResponsesRequestToGeminiSkipsCustomToolCalls(t *testing.T)
 	assert.Nil(t, got.Contents[1].Parts[0].FunctionResponse)
 }
 
+func TestConvertOpenAIResponsesRequestToGeminiRejectsUnsupportedTools(t *testing.T) {
+	got, err := convertResponsesToGemini(dto.OpenAIResponsesRequest{
+		Model: "gemini-test",
+		Input: mustGeminiRawMessage(t, "hello"),
+		Tools: mustGeminiRawMessage(t, []map[string]any{
+			{"type": "web_search_preview"},
+		}),
+	})
+
+	require.Error(t, err)
+	require.Nil(t, got)
+	assert.Contains(t, err.Error(), `tool type "web_search_preview"`)
+}
+
 func mustConvertResponsesToGemini(t *testing.T, req dto.OpenAIResponsesRequest) *dto.GeminiChatRequest {
 	t.Helper()
+	got, err := convertResponsesToGemini(req)
+	require.NoError(t, err)
+	return got
+}
+
+func convertResponsesToGemini(req dto.OpenAIResponsesRequest) (*dto.GeminiChatRequest, error) {
 	info := &relaycommon.RelayInfo{
 		OriginModelName: req.Model,
 		ChannelMeta: &relaycommon.ChannelMeta{
 			UpstreamModelName: req.Model,
 		},
 	}
 	got, err := (&Adaptor{}).ConvertOpenAIResponsesRequest(nil, info, req)
-	require.NoError(t, err)
+	if err != nil {
+		return nil, err
+	}
 	geminiReq, ok := got.(*dto.GeminiChatRequest)
-	require.True(t, ok)
-	return geminiReq
+	if !ok {
+		return nil, fmt.Errorf("unexpected converted request type %T", got)
+	}
+	return geminiReq, nil
 }
 
 func mustGeminiRawMessage(t *testing.T, value any) []byte {

relay/channel/task/doubao/adaptor.go

@@ -55,8 +55,8 @@ type requestPayload struct {
 	} `json:"tools,omitempty"`
 	SafetyIdentifier *string        `json:"safety_identifier,omitempty"`
 	Priority         *dto.IntValue  `json:"priority,omitempty"`
-	Resolution       string         `json:"resolution,omitempty"`
-	Ratio            string         `json:"ratio,omitempty"`
+	Resolution       *string        `json:"resolution,omitempty"`
+	Ratio            *string        `json:"ratio,omitempty"`
 	Duration         *dto.IntValue  `json:"duration,omitempty"`
 	Frames           *dto.IntValue  `json:"frames,omitempty"`
 	Seed             *dto.IntValue  `json:"seed,omitempty"`
@@ -173,8 +173,8 @@ func (a *TaskAdaptor) resolveSeedanceBillingInputs(c *gin.Context, req *relaycom
 	if !a.useSeedanceMediaProtocol() {
 		payload, err := a.convertToRequestPayload(req)
 		if err == nil && payload != nil {
-			if payload.Resolution != "" {
-				resolution = payload.Resolution
+			if payload.Resolution != nil && *payload.Resolution != "" {
+				resolution = *payload.Resolution
 			}
 			hasVideo = hasVideo || hasVideoInContent(payload.Content)
 		}

relay/channel/task/doubao/adaptor_media_protocol_test.go

@@ -267,5 +267,32 @@ func TestConvertToRequestPayloadPreservesSeedanceFields(t *testing.T) {
 	assert.Equal(t, "safety-123", *payload.SafetyIdentifier)
 	require.NotNil(t, payload.Priority)
 	assert.Equal(t, 0, int(*payload.Priority))
-	assert.Equal(t, "4k", payload.Resolution)
+	require.NotNil(t, payload.Resolution)
+	assert.Equal(t, "4k", *payload.Resolution)
+}
+
+func TestConvertToRequestPayloadPreservesExplicitEmptyOptionalStrings(t *testing.T) {
+	var req relaycommon.TaskSubmitReq
+	err := common.Unmarshal([]byte(`{
+		"model": "doubao-seedance-2-0-260128",
+		"prompt": "test",
+		"metadata": {
+			"resolution": "",
+			"ratio": ""
+		}
+	}`), &req)
+	require.NoError(t, err)
+
+	payload, err := (&TaskAdaptor{}).convertToRequestPayload(&req)
+	require.NoError(t, err)
+	require.NotNil(t, payload)
+	require.NotNil(t, payload.Resolution)
+	assert.Equal(t, "", *payload.Resolution)
+	require.NotNil(t, payload.Ratio)
+	assert.Equal(t, "", *payload.Ratio)
+
+	data, err := common.Marshal(payload)
+	require.NoError(t, err)
+	assert.Contains(t, string(data), `"resolution":""`)
+	assert.Contains(t, string(data), `"ratio":""`)
 }

service/convert.go

@@ -626,12 +626,7 @@ func ResponseOpenAI2Claude(openAIResponse *dto.OpenAITextResponse, info *relayco
 			claudeContent.Type = "tool_use"
 			claudeContent.Id = toolUse.ID
 			claudeContent.Name = toolUse.Function.Name
-			var mapParams map[string]interface{}
-			if err := common.Unmarshal([]byte(toolUse.Function.Arguments), &mapParams); err == nil {
-				claudeContent.Input = mapParams
-			} else {
-				claudeContent.Input = map[string]interface{}{"arguments": toolUse.Function.Arguments}
-			}
+			claudeContent.Input = parseToolCallArguments(toolUse.Function.Arguments)
 			contents = append(contents, claudeContent)
 		}
 	}
@@ -642,6 +637,17 @@ func ResponseOpenAI2Claude(openAIResponse *dto.OpenAITextResponse, info *relayco
 	return claudeResponse
 }
 
+func parseToolCallArguments(rawArgs string) map[string]interface{} {
+	if rawArgs == "" {
+		return make(map[string]interface{})
+	}
+	var args map[string]interface{}
+	if err := common.Unmarshal([]byte(rawArgs), &args); err != nil {
+		return map[string]interface{}{"arguments": rawArgs}
+	}
+	return args
+}
+
 func stopReasonOpenAI2Claude(reason string) string {
 	return reasonmap.OpenAIFinishReasonToClaudeStopReason(reason)
 }
@@ -873,19 +879,10 @@ func ResponseOpenAI2Gemini(openAIResponse *dto.OpenAITextResponse, info *relayco
 		if len(toolCalls) > 0 {
 			for _, toolCall := range toolCalls {
 				// 解析参数
-				var args map[string]interface{}
-				if toolCall.Function.Arguments != "" {
-					if err := json.Unmarshal([]byte(toolCall.Function.Arguments), &args); err != nil {
-						args = map[string]interface{}{"arguments": toolCall.Function.Arguments}
-					}
-				} else {
-					args = make(map[string]interface{})
-				}
-
 				part := dto.GeminiPart{
 					FunctionCall: &dto.FunctionCall{
 						FunctionName: toolCall.Function.Name,
-						Arguments:    args,
+						Arguments:    parseToolCallArguments(toolCall.Function.Arguments),
 					},
 				}
 				content.Parts = append(content.Parts, part)
@@ -967,19 +964,10 @@ func StreamResponseOpenAI2Gemini(openAIResponse *dto.ChatCompletionsStreamRespon
 		if choice.Delta.ToolCalls != nil {
 			for _, toolCall := range choice.Delta.ToolCalls {
 				// 解析参数
-				var args map[string]interface{}
-				if toolCall.Function.Arguments != "" {
-					if err := json.Unmarshal([]byte(toolCall.Function.Arguments), &args); err != nil {
-						args = map[string]interface{}{"arguments": toolCall.Function.Arguments}
-					}
-				} else {
-					args = make(map[string]interface{})
-				}
-
 				part := dto.GeminiPart{
 					FunctionCall: &dto.FunctionCall{
 						FunctionName: toolCall.Function.Name,
-						Arguments:    args,
+						Arguments:    parseToolCallArguments(toolCall.Function.Arguments),
 					},
 				}
 				content.Parts = append(content.Parts, part)

service/convert_test.go

@@ -50,6 +50,19 @@ func TestResponseOpenAI2GeminiPreservesTextWithToolCalls(t *testing.T) {
 	assert.Equal(t, map[string]interface{}{"q": "max-api"}, parts[1].FunctionCall.Arguments)
 }
 
+func TestResponseOpenAI2GeminiWrapsMalformedToolArguments(t *testing.T) {
+	resp := openAIResponseWithToolCallArguments(t, "{")
+	resp.Choices[0].Message.Content = ""
+	got := ResponseOpenAI2Gemini(resp, &relaycommon.RelayInfo{})
+
+	require.NotNil(t, got)
+	require.Len(t, got.Candidates, 1)
+	parts := got.Candidates[0].Content.Parts
+	require.Len(t, parts, 1)
+	require.NotNil(t, parts[0].FunctionCall)
+	assert.Equal(t, map[string]interface{}{"arguments": "{"}, parts[0].FunctionCall.Arguments)
+}
+
 func openAIResponseWithTextAndToolCall(t *testing.T) *dto.OpenAITextResponse {
 	return openAIResponseWithToolCallArguments(t, `{"q":"max-api"}`)
 }

service/openaicompat/chat_to_responses_response.go

@@ -109,11 +109,7 @@ func ChatCompletionsResponseToResponsesResponse(resp *dto.OpenAITextResponse, id
 		})
 	}
 	for i, toolCall := range choice.Message.ParseToolCalls() {
-		toolOutput, err := chatToolCallToResponsesOutput(toolCall, id, i, status)
-		if err != nil {
-			return nil, nil, err
-		}
-		out.Output = append(out.Output, toolOutput)
+		out.Output = append(out.Output, chatToolCallToResponsesOutput(toolCall, id, i, status))
 	}
 
 	return out, usage, nil
@@ -532,7 +528,7 @@ func responseOutputStatus(resp *dto.OpenAIResponsesResponse) string {
 	return "incomplete"
 }
 
-func chatToolCallToResponsesOutput(toolCall dto.ToolCallRequest, responseID string, index int, status string) (dto.ResponsesOutput, error) {
+func chatToolCallToResponsesOutput(toolCall dto.ToolCallRequest, responseID string, index int, status string) dto.ResponsesOutput {
 	callID := strings.TrimSpace(toolCall.ID)
 	if callID == "" {
 		callID = fmt.Sprintf("%s_call_%d", responseID, index)
@@ -545,15 +541,15 @@ func chatToolCallToResponsesOutput(toolCall dto.ToolCallRequest, responseID stri
 			CallId:    callID,
 			Name:      toolCall.Function.Name,
 			Arguments: chatArgumentsRawMessage(toolCall.Function.Arguments),
-		}, nil
+		}
 	}
 	return dto.ResponsesOutput{
 		Type:      toolCall.Type,
 		ID:        callID,
 		Status:    status,
 		CallId:    callID,
 		Arguments: toolCall.Custom,
-	}, nil
+	}
 }
 
 func chatArgumentsRawMessage(arguments string) []byte {