feat: publish v1.0.0-rc.36-custom.1

relaykit/relayconvert/internal/shared/gemini/request.go

@@ -0,0 +1,250 @@
+package gemini
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/QuantumNous/new-api/relaykit/dto"
+	"github.com/QuantumNous/new-api/relaykit/relayconvert/convmeta"
+	"github.com/QuantumNous/new-api/relaykit/relayconvert/reasoning"
+)
+
+var SupportedMimeTypes = map[string]bool{
+	"application/pdf": true,
+	"audio/mpeg":      true,
+	"audio/mp3":       true,
+	"audio/wav":       true,
+	"image/png":       true,
+	"image/jpeg":      true,
+	"image/jpg":       true,
+	"image/webp":      true,
+	"image/heic":      true,
+	"image/heif":      true,
+	"text/plain":      true,
+	"video/mov":       true,
+	"video/mpeg":      true,
+	"video/mp4":       true,
+	"video/mpg":       true,
+	"video/avi":       true,
+	"video/wmv":       true,
+	"video/mpegps":    true,
+	"video/flv":       true,
+}
+
+var SafetySettingCategories = []string{
+	"HARM_CATEGORY_HARASSMENT",
+	"HARM_CATEGORY_HATE_SPEECH",
+	"HARM_CATEGORY_SEXUALLY_EXPLICIT",
+	"HARM_CATEGORY_DANGEROUS_CONTENT",
+}
+
+const ThoughtSignatureBypassValue = "context_engineering_is_the_way_to_go"
+
+func ShouldAttachThoughtSignature(opts *convmeta.Options) bool {
+	return opts != nil && opts.Gemini.FunctionCallThoughtSignatureEnabled
+}
+
+func AttachThoughtSignatureBypass(opts *convmeta.Options, part *dto.GeminiPart) bool {
+	if part == nil || len(part.ThoughtSignature) > 0 || !ShouldAttachThoughtSignature(opts) {
+		return false
+	}
+	part.ThoughtSignature = []byte(strconv.Quote(ThoughtSignatureBypassValue))
+	return true
+}
+
+func AttachFunctionCallThoughtSignature(opts *convmeta.Options, part *dto.GeminiPart) bool {
+	if part == nil || !HasFunctionCallContent(part.FunctionCall) {
+		return false
+	}
+	return AttachThoughtSignatureBypass(opts, part)
+}
+
+func AttachFirstTextThoughtSignature(opts *convmeta.Options, parts []dto.GeminiPart) bool {
+	if !ShouldAttachThoughtSignature(opts) {
+		return false
+	}
+	for i := range parts {
+		if parts[i].Text != "" && len(parts[i].ThoughtSignature) == 0 {
+			parts[i].ThoughtSignature = []byte(strconv.Quote(ThoughtSignatureBypassValue))
+			return true
+		}
+	}
+	return false
+}
+
+func ApplyThinkingConfig(geminiRequest *dto.GeminiChatRequest, info convmeta.Meta, oaiRequest ...dto.GeneralOpenAIRequest) error {
+	opts := convmeta.OptionsOf(info)
+	if geminiRequest == nil {
+		return nil
+	}
+
+	modelName := convmeta.UpstreamModelName(info)
+	var source reasoning.Intent
+	crossProtocol := len(oaiRequest) > 0
+	if len(oaiRequest) > 0 {
+		if modelName == "" {
+			modelName = oaiRequest[0].Model
+		}
+		var err error
+		source, err = reasoning.FromOpenAIChat(&oaiRequest[0])
+		if err != nil {
+			return err
+		}
+	}
+
+	baseModel := modelName
+	suffix := reasoning.IntentFromState(convmeta.ReasoningStateOf(info))
+	preserveSuffix := opts.ShouldPreserveThinkingSuffix(modelName)
+	if info != nil && opts.ShouldPreserveThinkingSuffix(info.GetOriginModelName()) {
+		preserveSuffix = true
+	}
+	if preserveSuffix {
+		suffix = reasoning.Intent{}
+	}
+	// Native Gemini requests already use the target protocol. Without a host
+	// modifier, read portable effort metadata without running the capability
+	// renderer or rewriting provider-native controls.
+	if !crossProtocol && suffix.IsEmpty() {
+		if info != nil {
+			effort := ""
+			if config := geminiRequest.GenerationConfig.ThinkingConfig; config != nil {
+				effort = config.ThinkingLevel
+				if effort == "" && config.ThinkingBudget != nil {
+					effort = string(reasoning.EffortFromBudget(*config.ThinkingBudget))
+				}
+			}
+			info.SetReasoningEffort(effort)
+		}
+		return nil
+	}
+	native, err := reasoning.FromGemini(geminiRequest)
+	if err != nil {
+		return err
+	}
+	source = reasoning.ResolveGeminiEnabledDefault(baseModel, source, geminiRequest.GenerationConfig.MaxOutputTokens)
+	if native.HasStrength() && source.HasStrength() {
+		equivalent, compareErr := reasoning.EquivalentGeminiStrength(baseModel, native, source)
+		if compareErr != nil {
+			return compareErr
+		}
+		if !equivalent {
+			nativeEffort := reasoning.EffectiveEffort(native)
+			sourceEffort := reasoning.EffectiveEffort(source)
+			return fmt.Errorf("%w for model %q: Gemini thinking_config effort %q differs from standard effort %q", reasoning.ErrEffortConflict, modelName, nativeEffort, sourceEffort)
+		}
+		// Native Gemini configuration is the lossless representation. Once the
+		// two controls are equivalent, retain only portable visibility metadata
+		// from the standard representation.
+		if native.IncludeThoughts == nil {
+			native.IncludeThoughts = source.IncludeThoughts
+		}
+		source = reasoning.Intent{}
+	}
+	explicit, err := reasoning.MergeExplicit(native, source, modelName)
+	if err != nil {
+		return err
+	}
+	if explicit.HasStrength() && suffix.HasStrength() {
+		equivalent, compareErr := reasoning.EquivalentGeminiStrength(baseModel, explicit, suffix)
+		if compareErr != nil {
+			return compareErr
+		}
+		if equivalent {
+			if explicit.IncludeThoughts == nil {
+				explicit.IncludeThoughts = suffix.IncludeThoughts
+			}
+			suffix = reasoning.Intent{}
+		}
+	}
+	requested, err := reasoning.MergeExplicitAndSuffix(explicit, suffix, modelName)
+	if err != nil {
+		return err
+	}
+	requested = reasoning.ResolveGeminiEnabledDefault(baseModel, requested, geminiRequest.GenerationConfig.MaxOutputTokens)
+
+	if native.HasStrength() && !suffix.HasStrength() {
+		if explicit.IncludeThoughts != nil {
+			geminiRequest.GenerationConfig.ThinkingConfig.IncludeThoughts = explicit.IncludeThoughts
+		}
+		effort, err := reasoning.ValidateGeminiThinkingConfig(baseModel, geminiRequest.GenerationConfig.ThinkingConfig)
+		if err != nil {
+			return err
+		}
+		if info != nil && effort != "" {
+			info.SetReasoningEffort(string(effort))
+		}
+		return nil
+	}
+	if requested.IsEmpty() {
+		return nil
+	}
+	rendered, err := reasoning.RenderGemini(
+		baseModel,
+		requested,
+		geminiRequest.GenerationConfig.MaxOutputTokens,
+		opts.Gemini.ThinkingAdapterBudgetTokensPercentage,
+	)
+	if err != nil {
+		return err
+	}
+	geminiRequest.GenerationConfig.ThinkingConfig = rendered.Config
+	if info != nil && rendered.EffectiveEffort != "" {
+		info.SetReasoningEffort(string(rendered.EffectiveEffort))
+	}
+	return nil
+}
+
+func ParseStopSequences(stop any) []string {
+	if stop == nil {
+		return nil
+	}
+
+	switch v := stop.(type) {
+	case string:
+		if v != "" {
+			return []string{v}
+		}
+	case []string:
+		return v
+	case []interface{}:
+		sequences := make([]string, 0, len(v))
+		for _, item := range v {
+			if str, ok := item.(string); ok && str != "" {
+				sequences = append(sequences, str)
+			}
+		}
+		return sequences
+	}
+	return nil
+}
+
+func HasFunctionCallContent(call *dto.FunctionCall) bool {
+	if call == nil {
+		return false
+	}
+	if strings.TrimSpace(call.FunctionName) != "" {
+		return true
+	}
+
+	switch v := call.Arguments.(type) {
+	case nil:
+		return false
+	case string:
+		return strings.TrimSpace(v) != ""
+	case map[string]interface{}:
+		return len(v) > 0
+	case []interface{}:
+		return len(v) > 0
+	default:
+		return true
+	}
+}
+
+func SupportedMimeTypesList() []string {
+	keys := make([]string, 0, len(SupportedMimeTypes))
+	for key := range SupportedMimeTypes {
+		keys = append(keys, key)
+	}
+	return keys
+}

relaykit/relayconvert/internal/shared/gemini/schema.go

@@ -0,0 +1,256 @@
+package gemini
+
+import (
+	"strings"
+
+	"github.com/QuantumNous/new-api/relaykit/dto"
+)
+
+var geminiOpenAPISchemaAllowedFields = map[string]struct{}{
+	"anyOf":            {},
+	"default":          {},
+	"description":      {},
+	"enum":             {},
+	"example":          {},
+	"format":           {},
+	"items":            {},
+	"maxItems":         {},
+	"maxLength":        {},
+	"maxProperties":    {},
+	"maximum":          {},
+	"minItems":         {},
+	"minLength":        {},
+	"minProperties":    {},
+	"minimum":          {},
+	"nullable":         {},
+	"pattern":          {},
+	"properties":       {},
+	"propertyOrdering": {},
+	"required":         {},
+	"title":            {},
+	"type":             {},
+}
+
+const geminiFunctionSchemaMaxDepth = 64
+
+func CleanFunctionParameters(params interface{}) interface{} {
+	return cleanGeminiFunctionParametersWithDepth(params, 0)
+}
+
+func cleanGeminiFunctionParametersWithDepth(params interface{}, depth int) interface{} {
+	if params == nil {
+		return nil
+	}
+
+	if depth >= geminiFunctionSchemaMaxDepth {
+		return cleanGeminiFunctionParametersShallow(params)
+	}
+
+	switch v := params.(type) {
+	case map[string]interface{}:
+		cleanedMap := make(map[string]interface{}, len(v))
+		for key, val := range v {
+			if _, ok := geminiOpenAPISchemaAllowedFields[key]; ok {
+				cleanedMap[key] = val
+			}
+		}
+
+		normalizeGeminiSchemaTypeAndNullable(cleanedMap)
+
+		if props, ok := cleanedMap["properties"].(map[string]interface{}); ok && props != nil {
+			cleanedProps := make(map[string]interface{})
+			for propName, propValue := range props {
+				cleanedProps[propName] = cleanGeminiFunctionParametersWithDepth(propValue, depth+1)
+			}
+			cleanedMap["properties"] = cleanedProps
+		}
+
+		if items, ok := cleanedMap["items"].(map[string]interface{}); ok && items != nil {
+			cleanedMap["items"] = cleanGeminiFunctionParametersWithDepth(items, depth+1)
+		}
+		if itemsArray, ok := cleanedMap["items"].([]interface{}); ok && len(itemsArray) > 0 {
+			cleanedMap["items"] = cleanGeminiFunctionParametersWithDepth(itemsArray[0], depth+1)
+		}
+
+		if nested, ok := cleanedMap["anyOf"].([]interface{}); ok && nested != nil {
+			cleanedNested := make([]interface{}, len(nested))
+			for i, item := range nested {
+				cleanedNested[i] = cleanGeminiFunctionParametersWithDepth(item, depth+1)
+			}
+			cleanedMap["anyOf"] = cleanedNested
+		}
+
+		return cleanedMap
+	case []interface{}:
+		cleanedArray := make([]interface{}, len(v))
+		for i, item := range v {
+			cleanedArray[i] = cleanGeminiFunctionParametersWithDepth(item, depth+1)
+		}
+		return cleanedArray
+	default:
+		return params
+	}
+}
+
+func cleanGeminiFunctionParametersShallow(params interface{}) interface{} {
+	switch v := params.(type) {
+	case map[string]interface{}:
+		cleanedMap := make(map[string]interface{}, len(v))
+		for key, val := range v {
+			if _, ok := geminiOpenAPISchemaAllowedFields[key]; ok {
+				cleanedMap[key] = val
+			}
+		}
+		normalizeGeminiSchemaTypeAndNullable(cleanedMap)
+		delete(cleanedMap, "properties")
+		delete(cleanedMap, "items")
+		delete(cleanedMap, "anyOf")
+		return cleanedMap
+	case []interface{}:
+		return []interface{}{}
+	default:
+		return params
+	}
+}
+
+func normalizeGeminiSchemaTypeAndNullable(schema map[string]interface{}) {
+	rawType, ok := schema["type"]
+	if !ok || rawType == nil {
+		return
+	}
+
+	normalize := func(t string) (string, bool) {
+		switch strings.ToLower(strings.TrimSpace(t)) {
+		case "object":
+			return "OBJECT", false
+		case "array":
+			return "ARRAY", false
+		case "string":
+			return "STRING", false
+		case "integer":
+			return "INTEGER", false
+		case "number":
+			return "NUMBER", false
+		case "boolean":
+			return "BOOLEAN", false
+		case "null":
+			return "", true
+		default:
+			return t, false
+		}
+	}
+
+	switch typed := rawType.(type) {
+	case string:
+		normalized, isNull := normalize(typed)
+		if isNull {
+			schema["nullable"] = true
+			delete(schema, "type")
+			return
+		}
+		schema["type"] = normalized
+	case []interface{}:
+		nullable := false
+		var chosen string
+		for _, item := range typed {
+			if value, ok := item.(string); ok {
+				normalized, isNull := normalize(value)
+				if isNull {
+					nullable = true
+					continue
+				}
+				if chosen == "" {
+					chosen = normalized
+				}
+			}
+		}
+		if nullable {
+			schema["nullable"] = true
+		}
+		if chosen != "" {
+			schema["type"] = chosen
+		} else {
+			delete(schema, "type")
+		}
+	}
+}
+
+func RemoveAdditionalProperties(schema interface{}, depth int) interface{} {
+	if depth >= 5 {
+		return schema
+	}
+
+	value, ok := schema.(map[string]interface{})
+	if !ok || len(value) == 0 {
+		return schema
+	}
+	delete(value, "title")
+	delete(value, "$schema")
+	if typeVal, exists := value["type"]; !exists || (typeVal != "object" && typeVal != "array") {
+		return schema
+	}
+	switch value["type"] {
+	case "object":
+		delete(value, "additionalProperties")
+		if properties, ok := value["properties"].(map[string]interface{}); ok {
+			for key, nested := range properties {
+				properties[key] = RemoveAdditionalProperties(nested, depth+1)
+			}
+		}
+		for _, field := range []string{"allOf", "anyOf", "oneOf"} {
+			if nested, ok := value[field].([]interface{}); ok {
+				for i, item := range nested {
+					nested[i] = RemoveAdditionalProperties(item, depth+1)
+				}
+			}
+		}
+	case "array":
+		if items, ok := value["items"].(map[string]interface{}); ok {
+			value["items"] = RemoveAdditionalProperties(items, depth+1)
+		}
+	}
+
+	return value
+}
+
+func OpenAIToolChoiceToConfig(toolChoice any) *dto.ToolConfig {
+	if toolChoice == nil {
+		return nil
+	}
+
+	if toolChoiceStr, ok := toolChoice.(string); ok {
+		config := &dto.ToolConfig{
+			FunctionCallingConfig: &dto.FunctionCallingConfig{},
+		}
+		switch toolChoiceStr {
+		case "auto":
+			config.FunctionCallingConfig.Mode = "AUTO"
+		case "none":
+			config.FunctionCallingConfig.Mode = "NONE"
+		case "required":
+			config.FunctionCallingConfig.Mode = "ANY"
+		default:
+			config.FunctionCallingConfig.Mode = "AUTO"
+		}
+		return config
+	}
+
+	if toolChoiceMap, ok := toolChoice.(map[string]interface{}); ok {
+		if toolChoiceMap["type"] == "function" {
+			config := &dto.ToolConfig{
+				FunctionCallingConfig: &dto.FunctionCallingConfig{
+					Mode: "ANY",
+				},
+			}
+			if function, ok := toolChoiceMap["function"].(map[string]interface{}); ok {
+				if name, ok := function["name"].(string); ok && name != "" {
+					config.FunctionCallingConfig.AllowedFunctionNames = []string{name}
+				}
+			}
+			return config
+		}
+		return nil
+	}
+
+	return nil
+}