Вы не можете выбрать более 25 тем Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.
 
 
 

346 строки
11 KiB

  1. package helper
  2. import (
  3. "encoding/json"
  4. "errors"
  5. "fmt"
  6. "math"
  7. "strings"
  8. "github.com/QuantumNous/new-api/common"
  9. "github.com/QuantumNous/new-api/dto"
  10. "github.com/QuantumNous/new-api/logger"
  11. relaycommon "github.com/QuantumNous/new-api/relay/common"
  12. relayconstant "github.com/QuantumNous/new-api/relay/constant"
  13. "github.com/QuantumNous/new-api/types"
  14. "github.com/gin-gonic/gin"
  15. )
  16. func GetAndValidateRequest(c *gin.Context, format types.RelayFormat) (request dto.Request, err error) {
  17. if chatID, extractErr := relaycommon.ExtractTopLevelChatID(c); extractErr == nil && chatID != "" {
  18. relaycommon.SetRelayChatID(c, chatID)
  19. }
  20. relayMode := relayconstant.Path2RelayMode(c.Request.URL.Path)
  21. switch format {
  22. case types.RelayFormatOpenAI:
  23. request, err = GetAndValidateTextRequest(c, relayMode)
  24. case types.RelayFormatGemini:
  25. if strings.Contains(c.Request.URL.Path, ":embedContent") {
  26. request, err = GetAndValidateGeminiEmbeddingRequest(c)
  27. } else if strings.Contains(c.Request.URL.Path, ":batchEmbedContents") {
  28. request, err = GetAndValidateGeminiBatchEmbeddingRequest(c)
  29. } else {
  30. request, err = GetAndValidateGeminiRequest(c)
  31. }
  32. case types.RelayFormatClaude:
  33. request, err = GetAndValidateClaudeRequest(c)
  34. case types.RelayFormatOpenAIResponses:
  35. request, err = GetAndValidateResponsesRequest(c)
  36. case types.RelayFormatOpenAIResponsesCompaction:
  37. request, err = GetAndValidateResponsesCompactionRequest(c)
  38. case types.RelayFormatOpenAIImage:
  39. request, err = GetAndValidOpenAIImageRequest(c, relayMode)
  40. case types.RelayFormatEmbedding:
  41. request, err = GetAndValidateEmbeddingRequest(c, relayMode)
  42. case types.RelayFormatRerank:
  43. request, err = GetAndValidateRerankRequest(c)
  44. case types.RelayFormatOpenAIAudio:
  45. request, err = GetAndValidAudioRequest(c, relayMode)
  46. case types.RelayFormatOpenAIRealtime:
  47. request = &dto.BaseRequest{}
  48. default:
  49. return nil, fmt.Errorf("unsupported relay format: %s", format)
  50. }
  51. return request, err
  52. }
  53. func GetAndValidAudioRequest(c *gin.Context, relayMode int) (*dto.AudioRequest, error) {
  54. audioRequest := &dto.AudioRequest{}
  55. err := common.UnmarshalBodyReusable(c, audioRequest)
  56. if err != nil {
  57. return nil, err
  58. }
  59. switch relayMode {
  60. case relayconstant.RelayModeAudioSpeech:
  61. if audioRequest.Model == "" {
  62. return nil, errors.New("model is required")
  63. }
  64. default:
  65. if audioRequest.Model == "" {
  66. return nil, errors.New("model is required")
  67. }
  68. if audioRequest.ResponseFormat == "" {
  69. audioRequest.ResponseFormat = "json"
  70. }
  71. }
  72. return audioRequest, nil
  73. }
  74. func GetAndValidateRerankRequest(c *gin.Context) (*dto.RerankRequest, error) {
  75. var rerankRequest *dto.RerankRequest
  76. err := common.UnmarshalBodyReusable(c, &rerankRequest)
  77. if err != nil {
  78. logger.LogError(c, fmt.Sprintf("getAndValidateTextRequest failed: %s", err.Error()))
  79. return nil, types.NewError(err, types.ErrorCodeInvalidRequest, types.ErrOptionWithSkipRetry())
  80. }
  81. if rerankRequest.Query == "" {
  82. return nil, types.NewError(fmt.Errorf("query is empty"), types.ErrorCodeInvalidRequest, types.ErrOptionWithSkipRetry())
  83. }
  84. if len(rerankRequest.Documents) == 0 {
  85. return nil, types.NewError(fmt.Errorf("documents is empty"), types.ErrorCodeInvalidRequest, types.ErrOptionWithSkipRetry())
  86. }
  87. return rerankRequest, nil
  88. }
  89. func GetAndValidateEmbeddingRequest(c *gin.Context, relayMode int) (*dto.EmbeddingRequest, error) {
  90. var embeddingRequest *dto.EmbeddingRequest
  91. err := common.UnmarshalBodyReusable(c, &embeddingRequest)
  92. if err != nil {
  93. logger.LogError(c, fmt.Sprintf("getAndValidateTextRequest failed: %s", err.Error()))
  94. return nil, types.NewError(err, types.ErrorCodeInvalidRequest, types.ErrOptionWithSkipRetry())
  95. }
  96. if embeddingRequest.Input == nil {
  97. return nil, fmt.Errorf("input is empty")
  98. }
  99. if relayMode == relayconstant.RelayModeModerations && embeddingRequest.Model == "" {
  100. embeddingRequest.Model = "omni-moderation-latest"
  101. }
  102. if relayMode == relayconstant.RelayModeEmbeddings && embeddingRequest.Model == "" {
  103. embeddingRequest.Model = c.Param("model")
  104. }
  105. return embeddingRequest, nil
  106. }
  107. func GetAndValidateResponsesRequest(c *gin.Context) (*dto.OpenAIResponsesRequest, error) {
  108. request := &dto.OpenAIResponsesRequest{}
  109. err := common.UnmarshalBodyReusable(c, request)
  110. if err != nil {
  111. return nil, err
  112. }
  113. if request.Model == "" {
  114. return nil, errors.New("model is required")
  115. }
  116. if request.Input == nil {
  117. return nil, errors.New("input is required")
  118. }
  119. return request, nil
  120. }
  121. func GetAndValidateResponsesCompactionRequest(c *gin.Context) (*dto.OpenAIResponsesCompactionRequest, error) {
  122. request := &dto.OpenAIResponsesCompactionRequest{}
  123. if err := common.UnmarshalBodyReusable(c, request); err != nil {
  124. return nil, err
  125. }
  126. if request.Model == "" {
  127. return nil, errors.New("model is required")
  128. }
  129. return request, nil
  130. }
  131. func GetAndValidOpenAIImageRequest(c *gin.Context, relayMode int) (*dto.ImageRequest, error) {
  132. imageRequest := &dto.ImageRequest{}
  133. switch relayMode {
  134. case relayconstant.RelayModeImagesEdits:
  135. if strings.Contains(c.Request.Header.Get("Content-Type"), "multipart/form-data") {
  136. _, err := c.MultipartForm()
  137. if err != nil {
  138. return nil, fmt.Errorf("failed to parse image edit form request: %w", err)
  139. }
  140. formData := c.Request.PostForm
  141. imageRequest.Prompt = formData.Get("prompt")
  142. imageRequest.Model = formData.Get("model")
  143. imageRequest.N = uint(common.String2Int(formData.Get("n")))
  144. imageRequest.Quality = formData.Get("quality")
  145. imageRequest.Size = formData.Get("size")
  146. if imageValue := formData.Get("image"); imageValue != "" {
  147. imageRequest.Image, _ = json.Marshal(imageValue)
  148. }
  149. if imageRequest.Model == "gpt-image-1" {
  150. if imageRequest.Quality == "" {
  151. imageRequest.Quality = "standard"
  152. }
  153. }
  154. if imageRequest.N == 0 {
  155. imageRequest.N = 1
  156. }
  157. hasWatermark := formData.Has("watermark")
  158. if hasWatermark {
  159. watermark := formData.Get("watermark") == "true"
  160. imageRequest.Watermark = &watermark
  161. }
  162. break
  163. }
  164. fallthrough
  165. default:
  166. err := common.UnmarshalBodyReusable(c, imageRequest)
  167. if err != nil {
  168. return nil, err
  169. }
  170. if imageRequest.Model == "" {
  171. //imageRequest.Model = "dall-e-3"
  172. return nil, errors.New("model is required")
  173. }
  174. if strings.Contains(imageRequest.Size, "×") {
  175. return nil, errors.New("size an unexpected error occurred in the parameter, please use 'x' instead of the multiplication sign '×'")
  176. }
  177. // Not "256x256", "512x512", or "1024x1024"
  178. if imageRequest.Model == "dall-e-2" || imageRequest.Model == "dall-e" {
  179. if imageRequest.Size != "" && imageRequest.Size != "256x256" && imageRequest.Size != "512x512" && imageRequest.Size != "1024x1024" {
  180. return nil, errors.New("size must be one of 256x256, 512x512, or 1024x1024 for dall-e-2 or dall-e")
  181. }
  182. if imageRequest.Size == "" {
  183. imageRequest.Size = "1024x1024"
  184. }
  185. } else if imageRequest.Model == "dall-e-3" {
  186. if imageRequest.Size != "" && imageRequest.Size != "1024x1024" && imageRequest.Size != "1024x1792" && imageRequest.Size != "1792x1024" {
  187. return nil, errors.New("size must be one of 1024x1024, 1024x1792 or 1792x1024 for dall-e-3")
  188. }
  189. if imageRequest.Quality == "" {
  190. imageRequest.Quality = "standard"
  191. }
  192. if imageRequest.Size == "" {
  193. imageRequest.Size = "1024x1024"
  194. }
  195. } else if imageRequest.Model == "gpt-image-1" {
  196. if imageRequest.Quality == "" {
  197. imageRequest.Quality = "auto"
  198. }
  199. }
  200. //if imageRequest.Prompt == "" {
  201. // return nil, errors.New("prompt is required")
  202. //}
  203. if imageRequest.N == 0 {
  204. imageRequest.N = 1
  205. }
  206. }
  207. return imageRequest, nil
  208. }
  209. func GetAndValidateClaudeRequest(c *gin.Context) (textRequest *dto.ClaudeRequest, err error) {
  210. textRequest = &dto.ClaudeRequest{}
  211. err = c.ShouldBindJSON(textRequest)
  212. if err != nil {
  213. return nil, err
  214. }
  215. if textRequest.Messages == nil || len(textRequest.Messages) == 0 {
  216. return nil, errors.New("field messages is required")
  217. }
  218. if textRequest.Model == "" {
  219. return nil, errors.New("field model is required")
  220. }
  221. //if textRequest.Stream {
  222. // relayInfo.IsStream = true
  223. //}
  224. return textRequest, nil
  225. }
  226. func GetAndValidateTextRequest(c *gin.Context, relayMode int) (*dto.GeneralOpenAIRequest, error) {
  227. textRequest := &dto.GeneralOpenAIRequest{}
  228. err := common.UnmarshalBodyReusable(c, textRequest)
  229. if err != nil {
  230. return nil, err
  231. }
  232. if relayMode == relayconstant.RelayModeModerations && textRequest.Model == "" {
  233. textRequest.Model = "text-moderation-latest"
  234. }
  235. if relayMode == relayconstant.RelayModeEmbeddings && textRequest.Model == "" {
  236. textRequest.Model = c.Param("model")
  237. }
  238. if textRequest.MaxTokens > math.MaxInt32/2 {
  239. return nil, errors.New("max_tokens is invalid")
  240. }
  241. if textRequest.Model == "" {
  242. return nil, errors.New("model is required")
  243. }
  244. if textRequest.WebSearchOptions != nil {
  245. if textRequest.WebSearchOptions.SearchContextSize != "" {
  246. validSizes := map[string]bool{
  247. "high": true,
  248. "medium": true,
  249. "low": true,
  250. }
  251. if !validSizes[textRequest.WebSearchOptions.SearchContextSize] {
  252. return nil, errors.New("invalid search_context_size, must be one of: high, medium, low")
  253. }
  254. } else {
  255. textRequest.WebSearchOptions.SearchContextSize = "medium"
  256. }
  257. }
  258. switch relayMode {
  259. case relayconstant.RelayModeCompletions:
  260. if textRequest.Prompt == "" {
  261. return nil, errors.New("field prompt is required")
  262. }
  263. case relayconstant.RelayModeChatCompletions:
  264. // For FIM (Fill-in-the-middle) requests with prefix/suffix, messages is optional
  265. // It will be filled by provider-specific adaptors if needed (e.g., SiliconFlow)。Or it is allowed by model vendor(s) (e.g., DeepSeek)
  266. if len(textRequest.Messages) == 0 && textRequest.Prefix == nil && textRequest.Suffix == nil {
  267. return nil, errors.New("field messages is required")
  268. }
  269. case relayconstant.RelayModeEmbeddings:
  270. case relayconstant.RelayModeModerations:
  271. if textRequest.Input == nil || textRequest.Input == "" {
  272. return nil, errors.New("field input is required")
  273. }
  274. case relayconstant.RelayModeEdits:
  275. if textRequest.Instruction == "" {
  276. return nil, errors.New("field instruction is required")
  277. }
  278. }
  279. return textRequest, nil
  280. }
  281. func GetAndValidateGeminiRequest(c *gin.Context) (*dto.GeminiChatRequest, error) {
  282. request := &dto.GeminiChatRequest{}
  283. err := common.UnmarshalBodyReusable(c, request)
  284. if err != nil {
  285. return nil, err
  286. }
  287. if len(request.Contents) == 0 && len(request.Requests) == 0 {
  288. return nil, errors.New("contents is required")
  289. }
  290. //if c.Query("alt") == "sse" {
  291. // relayInfo.IsStream = true
  292. //}
  293. return request, nil
  294. }
  295. func GetAndValidateGeminiEmbeddingRequest(c *gin.Context) (*dto.GeminiEmbeddingRequest, error) {
  296. request := &dto.GeminiEmbeddingRequest{}
  297. err := common.UnmarshalBodyReusable(c, request)
  298. if err != nil {
  299. return nil, err
  300. }
  301. return request, nil
  302. }
  303. func GetAndValidateGeminiBatchEmbeddingRequest(c *gin.Context) (*dto.GeminiBatchEmbeddingRequest, error) {
  304. request := &dto.GeminiBatchEmbeddingRequest{}
  305. err := common.UnmarshalBodyReusable(c, request)
  306. if err != nil {
  307. return nil, err
  308. }
  309. return request, nil
  310. }