feat: 算力引擎 Go 后端核心（new-api）
- 统一 OpenAI 兼容 /v1 中继 + 渠道/额度/令牌/流水 - 各领域包：relay 模型网关、model 数据层、controller 管理 API
This commit is contained in:
@@ -0,0 +1,575 @@
|
||||
package advancedcustom
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strings"
|
||||
|
||||
"github.com/QuantumNous/new-api/constant"
|
||||
"github.com/QuantumNous/new-api/relay/channel"
|
||||
"github.com/QuantumNous/new-api/relay/channel/claude"
|
||||
"github.com/QuantumNous/new-api/relay/channel/gemini"
|
||||
"github.com/QuantumNous/new-api/relay/channel/openai"
|
||||
relaycommon "github.com/QuantumNous/new-api/relay/common"
|
||||
relayconstant "github.com/QuantumNous/new-api/relay/constant"
|
||||
"github.com/QuantumNous/new-api/relaykit/dto"
|
||||
"github.com/QuantumNous/new-api/relaykit/relayconvert"
|
||||
"github.com/QuantumNous/new-api/relaykit/types"
|
||||
"github.com/QuantumNous/new-api/service"
|
||||
"github.com/gin-gonic/gin"
|
||||
"github.com/samber/lo"
|
||||
)
|
||||
|
||||
const ChannelName = "advanced_custom"
|
||||
|
||||
const advancedCustomModelPlaceholder = "{model}"
|
||||
|
||||
type Adaptor struct {
|
||||
openaiAdaptor openai.Adaptor
|
||||
claudeAdaptor claude.Adaptor
|
||||
geminiAdaptor gemini.Adaptor
|
||||
|
||||
resolved bool
|
||||
converted bool
|
||||
route dto.AdvancedCustomRoute
|
||||
converter string
|
||||
}
|
||||
|
||||
func (a *Adaptor) Init(info *relaycommon.RelayInfo) {
|
||||
a.openaiAdaptor.Init(info)
|
||||
a.claudeAdaptor.Init(info)
|
||||
a.geminiAdaptor.Init(info)
|
||||
}
|
||||
|
||||
func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
|
||||
converter, err := a.resolveForConversion(c, info)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if converter == relayconvert.ConverterNone {
|
||||
return a.convertOpenAICompatibleRequest(c, info, request)
|
||||
}
|
||||
|
||||
switch converter {
|
||||
case relayconvert.ConverterOpenAIChatToClaudeMessages,
|
||||
relayconvert.ConverterOpenAIChatToOpenAIResponses,
|
||||
relayconvert.ConverterOpenAIChatToGeminiContent:
|
||||
result, err := service.ConvertRequestByID(c, info, converter, request)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return result.Value, nil
|
||||
default:
|
||||
return nil, fmt.Errorf("converter %q does not support OpenAI chat completions requests", converter)
|
||||
}
|
||||
}
|
||||
|
||||
func (a *Adaptor) ConvertClaudeRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.ClaudeRequest) (any, error) {
|
||||
converter, err := a.resolveForConversion(c, info)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
switch converter {
|
||||
case relayconvert.ConverterNone:
|
||||
return a.claudeAdaptor.ConvertClaudeRequest(c, info, request)
|
||||
case relayconvert.ConverterClaudeMessagesToOpenAIChat:
|
||||
result, err := service.ConvertRequestByID(c, info, converter, request)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
chatRequest, ok := result.Value.(*dto.GeneralOpenAIRequest)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("expected OpenAI chat completions request, got %T", result.Value)
|
||||
}
|
||||
return a.convertOpenAICompatibleRequest(c, info, chatRequest)
|
||||
default:
|
||||
return nil, fmt.Errorf("converter %q does not support Anthropic Messages requests", converter)
|
||||
}
|
||||
}
|
||||
|
||||
func (a *Adaptor) ConvertGeminiRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeminiChatRequest) (any, error) {
|
||||
converter, err := a.resolveForConversion(c, info)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
switch converter {
|
||||
case relayconvert.ConverterNone:
|
||||
return a.geminiAdaptor.ConvertGeminiRequest(c, info, request)
|
||||
case relayconvert.ConverterGeminiContentToOpenAIChat:
|
||||
result, err := service.ConvertRequestByID(c, info, converter, request)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
chatRequest, ok := result.Value.(*dto.GeneralOpenAIRequest)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("expected OpenAI chat completions request, got %T", result.Value)
|
||||
}
|
||||
return a.convertOpenAICompatibleRequest(c, info, chatRequest)
|
||||
default:
|
||||
return nil, fmt.Errorf("converter %q does not support Gemini generateContent requests", converter)
|
||||
}
|
||||
}
|
||||
|
||||
func (a *Adaptor) ConvertOpenAIResponsesRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.OpenAIResponsesRequest) (any, error) {
|
||||
converter, err := a.resolveForConversion(c, info)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
switch converter {
|
||||
case relayconvert.ConverterNone:
|
||||
return a.convertOpenAICompatibleResponsesRequest(c, info, request)
|
||||
case relayconvert.ConverterOpenAIResponsesToOpenAIChat:
|
||||
result, err := service.ConvertRequestByID(c, info, converter, request)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
chatRequest, ok := result.Value.(*dto.GeneralOpenAIRequest)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("expected OpenAI chat completions request, got %T", result.Value)
|
||||
}
|
||||
return a.convertOpenAICompatibleRequest(c, info, chatRequest)
|
||||
case relayconvert.ConverterOpenAIResponsesToGemini:
|
||||
result, err := service.ConvertRequestByID(c, info, converter, request)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
geminiRequest, ok := result.Value.(*dto.GeminiChatRequest)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("expected Gemini generateContent request, got %T", result.Value)
|
||||
}
|
||||
return geminiRequest, nil
|
||||
default:
|
||||
return nil, fmt.Errorf("converter %q does not support OpenAI Responses requests", converter)
|
||||
}
|
||||
}
|
||||
|
||||
func (a *Adaptor) ConvertEmbeddingRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.EmbeddingRequest) (any, error) {
|
||||
converter, err := a.resolveForConversion(c, info)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if converter != relayconvert.ConverterNone {
|
||||
return nil, fmt.Errorf("converter %q does not support embedding requests", converter)
|
||||
}
|
||||
return a.convertOpenAICompatibleEmbeddingRequest(c, info, request)
|
||||
}
|
||||
|
||||
func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
|
||||
converter, err := a.resolveForConversion(c, info)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if converter != relayconvert.ConverterNone {
|
||||
return nil, fmt.Errorf("converter %q does not support audio requests", converter)
|
||||
}
|
||||
return a.convertOpenAICompatibleAudioRequest(c, info, request)
|
||||
}
|
||||
|
||||
func (a *Adaptor) ConvertImageRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.ImageRequest) (any, error) {
|
||||
converter, err := a.resolveForConversion(c, info)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if converter != relayconvert.ConverterNone {
|
||||
return nil, fmt.Errorf("converter %q does not support image requests", converter)
|
||||
}
|
||||
return a.convertOpenAICompatibleImageRequest(c, info, request)
|
||||
}
|
||||
|
||||
func (a *Adaptor) ConvertRerankRequest(c *gin.Context, relayMode int, request dto.RerankRequest) (any, error) {
|
||||
a.converted = true
|
||||
return a.openaiAdaptor.ConvertRerankRequest(c, relayMode, request)
|
||||
}
|
||||
|
||||
func (a *Adaptor) GetRequestURL(info *relaycommon.RelayInfo) (string, error) {
|
||||
if err := a.resolve(nil, info); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return a.routeURL(info)
|
||||
}
|
||||
|
||||
func (a *Adaptor) BuildModelListRequest(info *relaycommon.RelayInfo) (string, http.Header, error) {
|
||||
return a.buildManagementRequest(info, dto.AdvancedCustomModelListPath)
|
||||
}
|
||||
|
||||
func (a *Adaptor) BuildBalanceRequest(info *relaycommon.RelayInfo) (string, http.Header, error) {
|
||||
return a.buildManagementRequest(info, dto.AdvancedCustomBalancePath)
|
||||
}
|
||||
|
||||
func (a *Adaptor) buildManagementRequest(info *relaycommon.RelayInfo, managementPath string) (string, http.Header, error) {
|
||||
if info == nil {
|
||||
return "", nil, errors.New("missing relay info")
|
||||
}
|
||||
config := info.ChannelOtherSettings.AdvancedCustom
|
||||
if config == nil {
|
||||
return "", nil, errors.New("advanced_custom is required")
|
||||
}
|
||||
if err := config.Validate(); err != nil {
|
||||
return "", nil, err
|
||||
}
|
||||
var route dto.AdvancedCustomRoute
|
||||
var ok bool
|
||||
switch managementPath {
|
||||
case dto.AdvancedCustomModelListPath:
|
||||
route, ok = config.ModelListRoute()
|
||||
case dto.AdvancedCustomBalancePath:
|
||||
route, ok = config.BalanceRoute()
|
||||
default:
|
||||
return "", nil, fmt.Errorf("unsupported advanced custom management path: %s", managementPath)
|
||||
}
|
||||
if !ok {
|
||||
return "", nil, fmt.Errorf("advanced custom channel does not configure a %s route", managementPath)
|
||||
}
|
||||
converter := strings.TrimSpace(route.Converter)
|
||||
if converter == "" {
|
||||
converter = relayconvert.ConverterNone
|
||||
}
|
||||
if converter != relayconvert.ConverterNone {
|
||||
return "", nil, fmt.Errorf("converter %q does not support %s requests", converter, managementPath)
|
||||
}
|
||||
|
||||
requestURL, err := buildRouteURL(route, converter, info)
|
||||
if err != nil {
|
||||
return "", nil, err
|
||||
}
|
||||
|
||||
header := http.Header{}
|
||||
auth := route.Auth
|
||||
if auth == nil {
|
||||
header.Set("Authorization", "Bearer "+info.ApiKey)
|
||||
return requestURL, header, nil
|
||||
}
|
||||
|
||||
switch strings.TrimSpace(auth.Type) {
|
||||
case dto.AdvancedCustomAuthTypeNone, dto.AdvancedCustomAuthTypeQuery:
|
||||
case dto.AdvancedCustomAuthTypeHeader:
|
||||
header.Set(strings.TrimSpace(auth.Name), applyAuthTemplate(auth.Value, info.ApiKey))
|
||||
default:
|
||||
return "", nil, fmt.Errorf("invalid advanced custom auth type: %s", auth.Type)
|
||||
}
|
||||
return requestURL, header, nil
|
||||
}
|
||||
|
||||
func (a *Adaptor) SetupRequestHeader(c *gin.Context, header *http.Header, info *relaycommon.RelayInfo) error {
|
||||
if err := a.resolve(c, info); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
channel.SetupApiRequestHeader(info, c, header)
|
||||
auth := a.route.Auth
|
||||
if auth == nil {
|
||||
header.Set("Authorization", "Bearer "+info.ApiKey)
|
||||
} else {
|
||||
switch strings.TrimSpace(auth.Type) {
|
||||
case dto.AdvancedCustomAuthTypeNone:
|
||||
case dto.AdvancedCustomAuthTypeHeader:
|
||||
header.Set(strings.TrimSpace(auth.Name), applyAuthTemplate(auth.Value, info.ApiKey))
|
||||
case dto.AdvancedCustomAuthTypeQuery:
|
||||
default:
|
||||
return fmt.Errorf("invalid advanced custom auth type: %s", auth.Type)
|
||||
}
|
||||
}
|
||||
|
||||
if shouldApplyClaudeHeaders(a.converter, info) {
|
||||
applyClaudeHeaders(c, header, info)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, requestBody io.Reader) (any, error) {
|
||||
if err := a.resolve(c, info); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if !a.converted && a.converter != relayconvert.ConverterNone {
|
||||
return nil, errors.New("advanced custom converter routes cannot be used with pass-through request body")
|
||||
}
|
||||
|
||||
if info.RelayMode == relayconstant.RelayModeAudioTranscription ||
|
||||
info.RelayMode == relayconstant.RelayModeAudioTranslation ||
|
||||
(info.RelayMode == relayconstant.RelayModeImagesEdits && !isJSONRequest(c)) {
|
||||
return channel.DoFormRequest(a, c, info, requestBody)
|
||||
}
|
||||
if info.RelayMode == relayconstant.RelayModeRealtime {
|
||||
return channel.DoWssRequest(a, c, info, requestBody)
|
||||
}
|
||||
return channel.DoApiRequest(a, c, info, requestBody)
|
||||
}
|
||||
|
||||
func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo) (usage any, err *types.NewAPIError) {
|
||||
if err := a.resolve(c, info); err != nil {
|
||||
return nil, types.NewOpenAIError(err, types.ErrorCodeInvalidRequest, http.StatusBadRequest, types.ErrOptionWithSkipRetry())
|
||||
}
|
||||
|
||||
switch a.converter {
|
||||
case relayconvert.ConverterNone:
|
||||
return a.doNativeResponse(c, resp, info)
|
||||
case relayconvert.ConverterClaudeMessagesToOpenAIChat,
|
||||
relayconvert.ConverterGeminiContentToOpenAIChat:
|
||||
return a.openaiAdaptor.DoResponse(c, resp, info)
|
||||
case relayconvert.ConverterOpenAIChatToClaudeMessages:
|
||||
return a.claudeAdaptor.DoResponse(c, resp, info)
|
||||
case relayconvert.ConverterOpenAIChatToGeminiContent:
|
||||
return a.geminiAdaptor.DoResponse(c, resp, info)
|
||||
case relayconvert.ConverterOpenAIResponsesToGemini:
|
||||
return a.geminiAdaptor.DoResponse(c, resp, info)
|
||||
case relayconvert.ConverterOpenAIChatToOpenAIResponses:
|
||||
if info.IsStream {
|
||||
return openai.OaiResponsesToChatStreamHandler(c, info, resp)
|
||||
}
|
||||
return openai.OaiResponsesToChatHandler(c, info, resp)
|
||||
case relayconvert.ConverterOpenAIResponsesToOpenAIChat:
|
||||
if info.IsStream {
|
||||
return openai.OaiChatToResponsesStreamHandler(c, info, resp)
|
||||
}
|
||||
return openai.OaiChatToResponsesHandler(c, info, resp)
|
||||
default:
|
||||
return nil, types.NewOpenAIError(fmt.Errorf("unsupported advanced custom converter: %s", a.converter), types.ErrorCodeInvalidRequest, http.StatusBadRequest, types.ErrOptionWithSkipRetry())
|
||||
}
|
||||
}
|
||||
|
||||
func (a *Adaptor) GetModelList() []string {
|
||||
models := make([]string, 0, len(openai.ModelList)+len(claude.ModelList)+len(gemini.ModelList))
|
||||
models = append(models, openai.ModelList...)
|
||||
models = append(models, claude.ModelList...)
|
||||
models = append(models, gemini.ModelList...)
|
||||
return lo.Uniq(models)
|
||||
}
|
||||
|
||||
func (a *Adaptor) GetChannelName() string {
|
||||
return ChannelName
|
||||
}
|
||||
|
||||
func (a *Adaptor) doNativeResponse(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo) (any, *types.NewAPIError) {
|
||||
switch info.RelayFormat {
|
||||
case types.RelayFormatClaude:
|
||||
return a.claudeAdaptor.DoResponse(c, resp, info)
|
||||
case types.RelayFormatGemini:
|
||||
return a.geminiAdaptor.DoResponse(c, resp, info)
|
||||
default:
|
||||
return a.openaiAdaptor.DoResponse(c, resp, info)
|
||||
}
|
||||
}
|
||||
|
||||
func (a *Adaptor) resolveForConversion(c *gin.Context, info *relaycommon.RelayInfo) (string, error) {
|
||||
if err := a.resolve(c, info); err != nil {
|
||||
return "", err
|
||||
}
|
||||
a.converted = true
|
||||
return a.converter, nil
|
||||
}
|
||||
|
||||
func (a *Adaptor) resolve(c *gin.Context, info *relaycommon.RelayInfo) error {
|
||||
if a.resolved {
|
||||
return nil
|
||||
}
|
||||
if info == nil {
|
||||
return errors.New("missing relay info")
|
||||
}
|
||||
config := info.ChannelOtherSettings.AdvancedCustom
|
||||
if config == nil {
|
||||
return errors.New("advanced_custom is required")
|
||||
}
|
||||
if err := config.Validate(); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
incomingPath := incomingRequestPath(c, info)
|
||||
route, ok := config.MatchPathForModel(incomingPath, info.OriginModelName)
|
||||
if ok {
|
||||
route.Converter = strings.TrimSpace(route.Converter)
|
||||
if route.Converter == "" {
|
||||
route.Converter = relayconvert.ConverterNone
|
||||
}
|
||||
a.route = route
|
||||
a.converter = route.Converter
|
||||
a.resolved = true
|
||||
return nil
|
||||
}
|
||||
return fmt.Errorf("advanced custom channel does not support request path %s for model %s", incomingPath, info.OriginModelName)
|
||||
}
|
||||
|
||||
func incomingRequestPath(c *gin.Context, info *relaycommon.RelayInfo) string {
|
||||
if c != nil && c.Request != nil && c.Request.URL != nil {
|
||||
return c.Request.URL.Path
|
||||
}
|
||||
if info == nil {
|
||||
return ""
|
||||
}
|
||||
return strings.Split(info.RequestURLPath, "?")[0]
|
||||
}
|
||||
|
||||
func (a *Adaptor) routeURL(info *relaycommon.RelayInfo) (string, error) {
|
||||
return buildRouteURL(a.route, a.converter, info)
|
||||
}
|
||||
|
||||
func buildRouteURL(route dto.AdvancedCustomRoute, converter string, info *relaycommon.RelayInfo) (string, error) {
|
||||
parsedURL, err := resolveUpstreamTargetURL(applyUpstreamPathTemplate(strings.TrimSpace(route.UpstreamPath), info), info)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if shouldUseGeminiStreamURL(converter, info) {
|
||||
useGeminiStreamGenerateContentURL(parsedURL)
|
||||
}
|
||||
if info != nil && info.RelayMode == relayconstant.RelayModeRealtime {
|
||||
switch parsedURL.Scheme {
|
||||
case "https":
|
||||
parsedURL.Scheme = "wss"
|
||||
case "http":
|
||||
parsedURL.Scheme = "ws"
|
||||
}
|
||||
}
|
||||
if route.Auth != nil && strings.TrimSpace(route.Auth.Type) == dto.AdvancedCustomAuthTypeQuery {
|
||||
query := parsedURL.Query()
|
||||
query.Set(strings.TrimSpace(route.Auth.Name), applyAuthTemplate(route.Auth.Value, info.ApiKey))
|
||||
parsedURL.RawQuery = query.Encode()
|
||||
}
|
||||
return parsedURL.String(), nil
|
||||
}
|
||||
|
||||
func resolveUpstreamTargetURL(upstreamPath string, info *relaycommon.RelayInfo) (*url.URL, error) {
|
||||
if strings.HasPrefix(upstreamPath, "/") {
|
||||
if strings.HasPrefix(upstreamPath, "//") {
|
||||
return nil, errors.New("advanced custom upstream path must be a full URL or a path starting with /")
|
||||
}
|
||||
if info == nil || strings.TrimSpace(info.ChannelBaseUrl) == "" {
|
||||
return nil, errors.New("channel base URL is required when advanced custom upstream path is relative")
|
||||
}
|
||||
return joinBaseURLAndUpstreamPath(info.ChannelBaseUrl, upstreamPath)
|
||||
}
|
||||
|
||||
parsedURL, err := url.Parse(upstreamPath)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if parsedURL.Scheme == "" || parsedURL.Host == "" {
|
||||
return nil, errors.New("advanced custom upstream path must be a full URL or a path starting with /")
|
||||
}
|
||||
if !strings.EqualFold(parsedURL.Scheme, "http") && !strings.EqualFold(parsedURL.Scheme, "https") {
|
||||
return nil, errors.New("advanced custom upstream path must use http or https")
|
||||
}
|
||||
return parsedURL, nil
|
||||
}
|
||||
|
||||
func joinBaseURLAndUpstreamPath(baseURL string, upstreamPath string) (*url.URL, error) {
|
||||
parsedBaseURL, err := url.Parse(strings.TrimSpace(baseURL))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if parsedBaseURL.Scheme == "" || parsedBaseURL.Host == "" {
|
||||
return nil, errors.New("channel base URL must be a full URL when advanced custom upstream path is relative")
|
||||
}
|
||||
if !strings.EqualFold(parsedBaseURL.Scheme, "http") && !strings.EqualFold(parsedBaseURL.Scheme, "https") {
|
||||
return nil, errors.New("channel base URL must use http or https when advanced custom upstream path is relative")
|
||||
}
|
||||
|
||||
parsedPath, err := url.Parse(upstreamPath)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
parsedBaseURL.Path = strings.TrimRight(parsedBaseURL.Path, "/") + "/" + strings.TrimLeft(parsedPath.Path, "/")
|
||||
parsedBaseURL.RawPath = ""
|
||||
parsedBaseURL.RawQuery = parsedPath.RawQuery
|
||||
parsedBaseURL.Fragment = parsedPath.Fragment
|
||||
return parsedBaseURL, nil
|
||||
}
|
||||
|
||||
func applyUpstreamPathTemplate(upstreamPath string, info *relaycommon.RelayInfo) string {
|
||||
if info == nil {
|
||||
return upstreamPath
|
||||
}
|
||||
return strings.ReplaceAll(upstreamPath, advancedCustomModelPlaceholder, info.UpstreamModelName)
|
||||
}
|
||||
|
||||
func shouldUseGeminiStreamURL(converter string, info *relaycommon.RelayInfo) bool {
|
||||
return info != nil &&
|
||||
info.IsStream &&
|
||||
(converter == relayconvert.ConverterOpenAIChatToGeminiContent ||
|
||||
converter == relayconvert.ConverterOpenAIResponsesToGemini)
|
||||
}
|
||||
|
||||
func useGeminiStreamGenerateContentURL(parsedURL *url.URL) {
|
||||
if strings.Contains(parsedURL.Path, ":generateContent") {
|
||||
parsedURL.Path = strings.Replace(parsedURL.Path, ":generateContent", ":streamGenerateContent", 1)
|
||||
}
|
||||
if strings.Contains(parsedURL.Path, ":streamGenerateContent") {
|
||||
query := parsedURL.Query()
|
||||
query.Set("alt", "sse")
|
||||
parsedURL.RawQuery = query.Encode()
|
||||
}
|
||||
}
|
||||
|
||||
func shouldApplyClaudeHeaders(converter string, info *relaycommon.RelayInfo) bool {
|
||||
return converter == relayconvert.ConverterOpenAIChatToClaudeMessages ||
|
||||
(converter == relayconvert.ConverterNone && info != nil && info.RelayFormat == types.RelayFormatClaude)
|
||||
}
|
||||
|
||||
func applyClaudeHeaders(c *gin.Context, header *http.Header, info *relaycommon.RelayInfo) {
|
||||
anthropicVersion := ""
|
||||
if c != nil && c.Request != nil {
|
||||
anthropicVersion = c.Request.Header.Get("anthropic-version")
|
||||
}
|
||||
if anthropicVersion == "" {
|
||||
anthropicVersion = "2023-06-01"
|
||||
}
|
||||
header.Set("anthropic-version", anthropicVersion)
|
||||
if c != nil {
|
||||
claude.CommonClaudeHeadersOperation(c, header, info)
|
||||
}
|
||||
}
|
||||
|
||||
func applyAuthTemplate(template string, apiKey string) string {
|
||||
return strings.ReplaceAll(template, "{api_key}", apiKey)
|
||||
}
|
||||
|
||||
func isJSONRequest(c *gin.Context) bool {
|
||||
if c == nil || c.Request == nil {
|
||||
return false
|
||||
}
|
||||
return strings.Contains(strings.ToLower(c.Request.Header.Get("Content-Type")), "application/json")
|
||||
}
|
||||
|
||||
func (a *Adaptor) convertOpenAICompatibleRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
|
||||
old := info.ChannelType
|
||||
info.ChannelType = constant.ChannelTypeOpenAI
|
||||
converted, err := a.openaiAdaptor.ConvertOpenAIRequest(c, info, request)
|
||||
info.ChannelType = old
|
||||
return converted, err
|
||||
}
|
||||
|
||||
func (a *Adaptor) convertOpenAICompatibleResponsesRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.OpenAIResponsesRequest) (any, error) {
|
||||
old := info.ChannelType
|
||||
info.ChannelType = constant.ChannelTypeOpenAI
|
||||
converted, err := a.openaiAdaptor.ConvertOpenAIResponsesRequest(c, info, request)
|
||||
info.ChannelType = old
|
||||
return converted, err
|
||||
}
|
||||
|
||||
func (a *Adaptor) convertOpenAICompatibleEmbeddingRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.EmbeddingRequest) (any, error) {
|
||||
old := info.ChannelType
|
||||
info.ChannelType = constant.ChannelTypeOpenAI
|
||||
converted, err := a.openaiAdaptor.ConvertEmbeddingRequest(c, info, request)
|
||||
info.ChannelType = old
|
||||
return converted, err
|
||||
}
|
||||
|
||||
func (a *Adaptor) convertOpenAICompatibleAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
|
||||
old := info.ChannelType
|
||||
info.ChannelType = constant.ChannelTypeOpenAI
|
||||
converted, err := a.openaiAdaptor.ConvertAudioRequest(c, info, request)
|
||||
info.ChannelType = old
|
||||
return converted, err
|
||||
}
|
||||
|
||||
func (a *Adaptor) convertOpenAICompatibleImageRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.ImageRequest) (any, error) {
|
||||
old := info.ChannelType
|
||||
info.ChannelType = constant.ChannelTypeOpenAI
|
||||
converted, err := a.openaiAdaptor.ConvertImageRequest(c, info, request)
|
||||
info.ChannelType = old
|
||||
return converted, err
|
||||
}
|
||||
@@ -0,0 +1,863 @@
|
||||
package advancedcustom
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"net/url"
|
||||
"testing"
|
||||
|
||||
"github.com/QuantumNous/new-api/common"
|
||||
"github.com/QuantumNous/new-api/constant"
|
||||
relaycommon "github.com/QuantumNous/new-api/relay/common"
|
||||
relayconstant "github.com/QuantumNous/new-api/relay/constant"
|
||||
"github.com/QuantumNous/new-api/relaykit/dto"
|
||||
"github.com/QuantumNous/new-api/relaykit/relayconvert"
|
||||
"github.com/QuantumNous/new-api/relaykit/types"
|
||||
"github.com/QuantumNous/new-api/setting/model_setting"
|
||||
"github.com/gin-gonic/gin"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
func TestAdaptorUsesExactRouteAndQueryAuth(t *testing.T) {
|
||||
adaptor := &Adaptor{}
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1/messages",
|
||||
UpstreamPath: "https://upstream.example/v1/chat/completions?existing=1",
|
||||
Converter: relayconvert.ConverterClaudeMessagesToOpenAIChat,
|
||||
Auth: &dto.AdvancedCustomRouteAuth{
|
||||
Type: dto.AdvancedCustomAuthTypeQuery,
|
||||
Name: "api_key",
|
||||
Value: "{api_key}",
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
info.RequestURLPath = "/v1/messages?client=1"
|
||||
|
||||
requestURL, err := adaptor.GetRequestURL(info)
|
||||
require.NoError(t, err)
|
||||
|
||||
parsedURL, err := url.Parse(requestURL)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, "https", parsedURL.Scheme)
|
||||
assert.Equal(t, "upstream.example", parsedURL.Host)
|
||||
assert.Equal(t, "/v1/chat/completions", parsedURL.Path)
|
||||
assert.Equal(t, "1", parsedURL.Query().Get("existing"))
|
||||
assert.Equal(t, "sk-test", parsedURL.Query().Get("api_key"))
|
||||
}
|
||||
|
||||
func TestAdaptorJoinsUpstreamPathWithChannelBaseURL(t *testing.T) {
|
||||
adaptor := &Adaptor{}
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1/chat/completions",
|
||||
UpstreamPath: "/proxy/v1/chat/completions?existing=1",
|
||||
Converter: relayconvert.ConverterNone,
|
||||
Auth: &dto.AdvancedCustomRouteAuth{
|
||||
Type: dto.AdvancedCustomAuthTypeQuery,
|
||||
Name: "api_key",
|
||||
Value: "{api_key}",
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
info.ChannelBaseUrl = "https://gateway.example/base"
|
||||
|
||||
requestURL, err := adaptor.GetRequestURL(info)
|
||||
require.NoError(t, err)
|
||||
|
||||
parsedURL, err := url.Parse(requestURL)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, "https", parsedURL.Scheme)
|
||||
assert.Equal(t, "gateway.example", parsedURL.Host)
|
||||
assert.Equal(t, "/base/proxy/v1/chat/completions", parsedURL.Path)
|
||||
assert.Equal(t, "1", parsedURL.Query().Get("existing"))
|
||||
assert.Equal(t, "sk-test", parsedURL.Query().Get("api_key"))
|
||||
}
|
||||
|
||||
func TestAdaptorReturnsErrorWhenUpstreamPathNeedsMissingBaseURL(t *testing.T) {
|
||||
adaptor := &Adaptor{}
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1/chat/completions",
|
||||
UpstreamPath: "/v1/chat/completions",
|
||||
Converter: relayconvert.ConverterNone,
|
||||
},
|
||||
},
|
||||
})
|
||||
info.ChannelBaseUrl = ""
|
||||
|
||||
_, err := adaptor.GetRequestURL(info)
|
||||
require.Error(t, err)
|
||||
assert.Contains(t, err.Error(), "base URL is required")
|
||||
}
|
||||
|
||||
func TestAdaptorSetupRequestHeaderUsesDefaultBearerAuth(t *testing.T) {
|
||||
adaptor := &Adaptor{}
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1/chat/completions",
|
||||
UpstreamPath: "https://upstream.example/v1/chat/completions",
|
||||
Converter: relayconvert.ConverterNone,
|
||||
},
|
||||
},
|
||||
})
|
||||
c := advancedCustomGinContext("/v1/chat/completions")
|
||||
header := http.Header{}
|
||||
|
||||
require.NoError(t, adaptor.SetupRequestHeader(c, &header, info))
|
||||
assert.Equal(t, "Bearer sk-test", header.Get("Authorization"))
|
||||
}
|
||||
|
||||
func TestAdaptorSetupRequestHeaderUsesConfiguredHeaderAuth(t *testing.T) {
|
||||
adaptor := &Adaptor{}
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1/chat/completions",
|
||||
UpstreamPath: "https://upstream.example/v1/chat/completions",
|
||||
Converter: relayconvert.ConverterNone,
|
||||
Auth: &dto.AdvancedCustomRouteAuth{
|
||||
Type: dto.AdvancedCustomAuthTypeHeader,
|
||||
Name: "x-api-key",
|
||||
Value: "{api_key}",
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
c := advancedCustomGinContext("/v1/chat/completions")
|
||||
header := http.Header{}
|
||||
|
||||
require.NoError(t, adaptor.SetupRequestHeader(c, &header, info))
|
||||
assert.Empty(t, header.Get("Authorization"))
|
||||
assert.Equal(t, "sk-test", header.Get("x-api-key"))
|
||||
}
|
||||
|
||||
func TestAdaptorSetupRequestHeaderAddsClaudeDefaultHeaders(t *testing.T) {
|
||||
adaptor := &Adaptor{}
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1/messages",
|
||||
UpstreamPath: "https://api.anthropic.com/v1/messages",
|
||||
Converter: relayconvert.ConverterNone,
|
||||
Auth: &dto.AdvancedCustomRouteAuth{
|
||||
Type: dto.AdvancedCustomAuthTypeHeader,
|
||||
Name: "x-api-key",
|
||||
Value: "{api_key}",
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
info.RelayFormat = types.RelayFormatClaude
|
||||
c := advancedCustomGinContext("/v1/messages")
|
||||
header := http.Header{}
|
||||
|
||||
require.NoError(t, adaptor.SetupRequestHeader(c, &header, info))
|
||||
assert.Equal(t, "sk-test", header.Get("x-api-key"))
|
||||
assert.Equal(t, "2023-06-01", header.Get("anthropic-version"))
|
||||
}
|
||||
|
||||
func TestAdaptorReturnsErrorWhenNoRouteMatchesPath(t *testing.T) {
|
||||
adaptor := &Adaptor{}
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1/messages",
|
||||
UpstreamPath: "https://upstream.example/v1/chat/completions",
|
||||
Converter: relayconvert.ConverterClaudeMessagesToOpenAIChat,
|
||||
},
|
||||
},
|
||||
})
|
||||
info.RequestURLPath = "/v1/chat/completions"
|
||||
|
||||
_, err := adaptor.GetRequestURL(info)
|
||||
require.Error(t, err)
|
||||
assert.Contains(t, err.Error(), "does not support request path")
|
||||
}
|
||||
|
||||
func TestAdaptorReplacesModelPlaceholderInRouteURL(t *testing.T) {
|
||||
adaptor := &Adaptor{}
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1/chat/completions",
|
||||
UpstreamPath: "https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent",
|
||||
Converter: relayconvert.ConverterOpenAIChatToGeminiContent,
|
||||
Auth: &dto.AdvancedCustomRouteAuth{
|
||||
Type: dto.AdvancedCustomAuthTypeQuery,
|
||||
Name: "key",
|
||||
Value: "{api_key}",
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
info.UpstreamModelName = "gemini-2.5-flash"
|
||||
|
||||
requestURL, err := adaptor.GetRequestURL(info)
|
||||
require.NoError(t, err)
|
||||
|
||||
parsedURL, err := url.Parse(requestURL)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, "/v1beta/models/gemini-2.5-flash:generateContent", parsedURL.Path)
|
||||
assert.Equal(t, "sk-test", parsedURL.Query().Get("key"))
|
||||
assert.Empty(t, parsedURL.Query().Get("alt"))
|
||||
}
|
||||
|
||||
func TestAdaptorSwitchesGeminiGenerateContentURLForStream(t *testing.T) {
|
||||
adaptor := &Adaptor{}
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1/chat/completions",
|
||||
UpstreamPath: "https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent?existing=1",
|
||||
Converter: relayconvert.ConverterOpenAIChatToGeminiContent,
|
||||
Auth: &dto.AdvancedCustomRouteAuth{
|
||||
Type: dto.AdvancedCustomAuthTypeQuery,
|
||||
Name: "key",
|
||||
Value: "{api_key}",
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
info.UpstreamModelName = "gemini-2.5-pro"
|
||||
info.IsStream = true
|
||||
|
||||
requestURL, err := adaptor.GetRequestURL(info)
|
||||
require.NoError(t, err)
|
||||
|
||||
parsedURL, err := url.Parse(requestURL)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, "/v1beta/models/gemini-2.5-pro:streamGenerateContent", parsedURL.Path)
|
||||
assert.Equal(t, "sse", parsedURL.Query().Get("alt"))
|
||||
assert.Equal(t, "1", parsedURL.Query().Get("existing"))
|
||||
assert.Equal(t, "sk-test", parsedURL.Query().Get("key"))
|
||||
}
|
||||
|
||||
func TestAdaptorMatchesGeminiIncomingPathTemplate(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
requestURLPath string
|
||||
wantRequestPath string
|
||||
}{
|
||||
{
|
||||
name: "generate content",
|
||||
requestURLPath: "/v1beta/models/gemini-2.5-flash:generateContent",
|
||||
wantRequestPath: "/v1/chat/completions",
|
||||
},
|
||||
{
|
||||
name: "stream generate content",
|
||||
requestURLPath: "/v1beta/models/gemini-2.5-flash:streamGenerateContent?alt=sse",
|
||||
wantRequestPath: "/v1/chat/completions",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
adaptor := &Adaptor{}
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1beta/models/{model}:generateContent",
|
||||
UpstreamPath: "https://upstream.example/v1/chat/completions",
|
||||
Converter: relayconvert.ConverterGeminiContentToOpenAIChat,
|
||||
},
|
||||
},
|
||||
})
|
||||
info.RequestURLPath = tt.requestURLPath
|
||||
|
||||
requestURL, err := adaptor.GetRequestURL(info)
|
||||
require.NoError(t, err)
|
||||
|
||||
parsedURL, err := url.Parse(requestURL)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, tt.wantRequestPath, parsedURL.Path)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdaptorBuildModelListRequestUsesConfiguredRouteAuth(t *testing.T) {
|
||||
adaptor := &Adaptor{}
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1/models",
|
||||
UpstreamPath: "/provider/models",
|
||||
Converter: relayconvert.ConverterNone,
|
||||
Auth: &dto.AdvancedCustomRouteAuth{
|
||||
Type: dto.AdvancedCustomAuthTypeHeader,
|
||||
Name: "x-api-key",
|
||||
Value: "token {api_key}",
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
info.RequestURLPath = "/v1/models"
|
||||
|
||||
requestURL, header, err := adaptor.BuildModelListRequest(info)
|
||||
require.NoError(t, err)
|
||||
|
||||
parsedURL, err := url.Parse(requestURL)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, "fallback.example", parsedURL.Host)
|
||||
assert.Equal(t, "/provider/models", parsedURL.Path)
|
||||
assert.Equal(t, "token sk-test", header.Get("x-api-key"))
|
||||
assert.Empty(t, header.Get("Authorization"))
|
||||
}
|
||||
|
||||
func TestAdaptorBuildModelListRequestUsesConfiguredQueryAuth(t *testing.T) {
|
||||
adaptor := &Adaptor{}
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1/models",
|
||||
UpstreamPath: "https://upstream.example/v1/models?existing=1",
|
||||
Converter: relayconvert.ConverterNone,
|
||||
Auth: &dto.AdvancedCustomRouteAuth{
|
||||
Type: dto.AdvancedCustomAuthTypeQuery,
|
||||
Name: "key",
|
||||
Value: "{api_key}",
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
info.RequestURLPath = "/v1/models"
|
||||
|
||||
requestURL, header, err := adaptor.BuildModelListRequest(info)
|
||||
require.NoError(t, err)
|
||||
|
||||
parsedURL, err := url.Parse(requestURL)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, "upstream.example", parsedURL.Host)
|
||||
assert.Equal(t, "/v1/models", parsedURL.Path)
|
||||
assert.Equal(t, "1", parsedURL.Query().Get("existing"))
|
||||
assert.Equal(t, "sk-test", parsedURL.Query().Get("key"))
|
||||
assert.Empty(t, header.Get("Authorization"))
|
||||
}
|
||||
|
||||
func TestAdaptorBuildModelListRequestDefaultAndNoAuth(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
auth *dto.AdvancedCustomRouteAuth
|
||||
wantAuthorization string
|
||||
}{
|
||||
{
|
||||
name: "default bearer",
|
||||
wantAuthorization: "Bearer sk-test",
|
||||
},
|
||||
{
|
||||
name: "no authentication",
|
||||
auth: &dto.AdvancedCustomRouteAuth{
|
||||
Type: dto.AdvancedCustomAuthTypeNone,
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: dto.AdvancedCustomModelListPath,
|
||||
UpstreamPath: "/provider/models",
|
||||
Auth: tt.auth,
|
||||
},
|
||||
},
|
||||
})
|
||||
info.RequestURLPath = "/unrelated/path"
|
||||
|
||||
requestURL, header, err := (&Adaptor{}).BuildModelListRequest(info)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, "https://fallback.example/provider/models", requestURL)
|
||||
assert.Equal(t, tt.wantAuthorization, header.Get("Authorization"))
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdaptorBuildModelListRequestDoesNotReuseRelayRoute(t *testing.T) {
|
||||
adaptor := &Adaptor{}
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1/chat/completions",
|
||||
UpstreamPath: "/chat",
|
||||
},
|
||||
{
|
||||
IncomingPath: dto.AdvancedCustomModelListPath,
|
||||
UpstreamPath: "/provider/models",
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
chatURL, err := adaptor.GetRequestURL(info)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, "https://fallback.example/chat", chatURL)
|
||||
|
||||
modelURL, header, err := adaptor.BuildModelListRequest(info)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, "https://fallback.example/provider/models", modelURL)
|
||||
assert.Equal(t, "Bearer sk-test", header.Get("Authorization"))
|
||||
}
|
||||
|
||||
func TestAdaptorBuildModelListRequestRequiresConfiguredRoute(t *testing.T) {
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1/chat/completions",
|
||||
UpstreamPath: "/v1/chat/completions",
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
_, _, err := (&Adaptor{}).BuildModelListRequest(info)
|
||||
require.Error(t, err)
|
||||
assert.Contains(t, err.Error(), "does not configure a /v1/models route")
|
||||
}
|
||||
|
||||
func TestAdaptorBuildBalanceRequestUsesConfiguredRoute(t *testing.T) {
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: dto.AdvancedCustomModelListPath,
|
||||
UpstreamPath: "/provider/models",
|
||||
},
|
||||
{
|
||||
IncomingPath: dto.AdvancedCustomBalancePath,
|
||||
UpstreamPath: "/provider/balance?existing=1",
|
||||
Auth: &dto.AdvancedCustomRouteAuth{
|
||||
Type: dto.AdvancedCustomAuthTypeQuery,
|
||||
Name: "token",
|
||||
Value: "prefix-{api_key}",
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
requestURL, header, err := (&Adaptor{}).BuildBalanceRequest(info)
|
||||
require.NoError(t, err)
|
||||
|
||||
parsedURL, err := url.Parse(requestURL)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, "/provider/balance", parsedURL.Path)
|
||||
assert.Equal(t, "1", parsedURL.Query().Get("existing"))
|
||||
assert.Equal(t, "prefix-sk-test", parsedURL.Query().Get("token"))
|
||||
assert.Empty(t, header.Get("Authorization"))
|
||||
}
|
||||
|
||||
func TestAdaptorBuildBalanceRequestRequiresConfiguredRoute(t *testing.T) {
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{{
|
||||
IncomingPath: dto.AdvancedCustomModelListPath,
|
||||
UpstreamPath: "/provider/models",
|
||||
}},
|
||||
})
|
||||
|
||||
_, _, err := (&Adaptor{}).BuildBalanceRequest(info)
|
||||
require.Error(t, err)
|
||||
assert.Contains(t, err.Error(), "does not configure a /v1/dashboard/billing/credit_grants route")
|
||||
}
|
||||
|
||||
func TestAdaptorConvertsResponsesRequestToOpenAIChatUpstream(t *testing.T) {
|
||||
adaptor := &Adaptor{}
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1/responses",
|
||||
UpstreamPath: "/v1/chat/completions",
|
||||
Converter: relayconvert.ConverterOpenAIResponsesToOpenAIChat,
|
||||
},
|
||||
},
|
||||
})
|
||||
info.RelayMode = relayconstant.RelayModeResponses
|
||||
info.RequestURLPath = "/v1/responses"
|
||||
gin.SetMode(gin.TestMode)
|
||||
recorder := httptest.NewRecorder()
|
||||
c, _ := gin.CreateTestContext(recorder)
|
||||
c.Request = httptest.NewRequest(http.MethodPost, "/v1/responses", nil)
|
||||
c.Request.Header.Set("Content-Type", "application/json")
|
||||
|
||||
converted, err := adaptor.ConvertOpenAIResponsesRequest(c, info, dto.OpenAIResponsesRequest{
|
||||
Model: "gpt-test",
|
||||
Instructions: mustAdvancedCustomRawMessage(t, "system rules"),
|
||||
Input: mustAdvancedCustomRawMessage(t, "hello"),
|
||||
})
|
||||
require.NoError(t, err)
|
||||
|
||||
chatReq, ok := converted.(*dto.GeneralOpenAIRequest)
|
||||
require.True(t, ok)
|
||||
assert.Equal(t, "gpt-test", chatReq.Model)
|
||||
require.Len(t, chatReq.Messages, 2)
|
||||
assert.Equal(t, "system", chatReq.Messages[0].Role)
|
||||
assert.Equal(t, "system rules", chatReq.Messages[0].StringContent())
|
||||
assert.Equal(t, "user", chatReq.Messages[1].Role)
|
||||
assert.Equal(t, "hello", chatReq.Messages[1].StringContent())
|
||||
|
||||
requestURL, err := adaptor.GetRequestURL(info)
|
||||
require.NoError(t, err)
|
||||
parsedURL, err := url.Parse(requestURL)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, "/v1/chat/completions", parsedURL.Path)
|
||||
}
|
||||
|
||||
func TestAdaptorSelectsDuplicateResponsesRoutesByModel(t *testing.T) {
|
||||
config := &dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1/responses",
|
||||
UpstreamPath: "/v1/chat/completions",
|
||||
Converter: relayconvert.ConverterOpenAIResponsesToOpenAIChat,
|
||||
Models: []string{"gpt-test"},
|
||||
},
|
||||
{
|
||||
IncomingPath: "/v1/responses",
|
||||
UpstreamPath: "/v1beta/models/{model}:generateContent",
|
||||
Converter: relayconvert.ConverterOpenAIResponsesToGemini,
|
||||
Models: []string{"gemini-test"},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
chatAdaptor := &Adaptor{}
|
||||
chatInfo := advancedCustomRelayInfo(config)
|
||||
chatInfo.RelayFormat = types.RelayFormatOpenAIResponses
|
||||
chatInfo.RelayMode = relayconstant.RelayModeResponses
|
||||
chatInfo.RequestURLPath = "/v1/responses"
|
||||
chatInfo.OriginModelName = "gpt-test"
|
||||
chatInfo.UpstreamModelName = "gpt-test"
|
||||
chatConverted, err := chatAdaptor.ConvertOpenAIResponsesRequest(advancedCustomGinContext("/v1/responses"), chatInfo, dto.OpenAIResponsesRequest{
|
||||
Model: "gpt-test",
|
||||
Input: mustAdvancedCustomRawMessage(t, "hello"),
|
||||
})
|
||||
require.NoError(t, err)
|
||||
_, ok := chatConverted.(*dto.GeneralOpenAIRequest)
|
||||
require.True(t, ok)
|
||||
|
||||
geminiAdaptor := &Adaptor{}
|
||||
geminiInfo := advancedCustomRelayInfo(config)
|
||||
geminiInfo.RelayFormat = types.RelayFormatOpenAIResponses
|
||||
geminiInfo.RelayMode = relayconstant.RelayModeResponses
|
||||
geminiInfo.RequestURLPath = "/v1/responses"
|
||||
geminiInfo.OriginModelName = "gemini-test"
|
||||
geminiInfo.UpstreamModelName = "gemini-test"
|
||||
geminiInfo.IsStream = true
|
||||
geminiConverted, err := geminiAdaptor.ConvertOpenAIResponsesRequest(advancedCustomGinContext("/v1/responses"), geminiInfo, dto.OpenAIResponsesRequest{
|
||||
Model: "gemini-test",
|
||||
Input: mustAdvancedCustomRawMessage(t, "hello"),
|
||||
})
|
||||
require.NoError(t, err)
|
||||
_, ok = geminiConverted.(*dto.GeminiChatRequest)
|
||||
require.True(t, ok)
|
||||
|
||||
requestURL, err := geminiAdaptor.GetRequestURL(geminiInfo)
|
||||
require.NoError(t, err)
|
||||
parsedURL, err := url.Parse(requestURL)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, "/v1beta/models/gemini-test:streamGenerateContent", parsedURL.Path)
|
||||
assert.Equal(t, "sse", parsedURL.Query().Get("alt"))
|
||||
}
|
||||
|
||||
func TestAdaptorResponsesToGeminiUsesResponsesBridge(t *testing.T) {
|
||||
adaptor := &Adaptor{}
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1/responses",
|
||||
UpstreamPath: "/v1beta/models/{model}:generateContent",
|
||||
Converter: relayconvert.ConverterOpenAIResponsesToGemini,
|
||||
Models: []string{"gemini-test"},
|
||||
},
|
||||
},
|
||||
})
|
||||
info.RelayFormat = types.RelayFormatOpenAIResponses
|
||||
info.RelayMode = relayconstant.RelayModeResponses
|
||||
info.RequestURLPath = "/v1/responses"
|
||||
info.OriginModelName = "gemini-test"
|
||||
info.UpstreamModelName = "gemini-test"
|
||||
gin.SetMode(gin.TestMode)
|
||||
recorder := httptest.NewRecorder()
|
||||
c, _ := gin.CreateTestContext(recorder)
|
||||
c.Request = httptest.NewRequest(http.MethodPost, "/v1/responses", nil)
|
||||
c.Request.Header.Set("Content-Type", "application/json")
|
||||
|
||||
payload := dto.GeminiChatResponse{
|
||||
Candidates: []dto.GeminiChatCandidate{
|
||||
{
|
||||
Content: dto.GeminiChatContent{
|
||||
Role: "model",
|
||||
Parts: []dto.GeminiPart{
|
||||
{Text: "hello"},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
UsageMetadata: dto.GeminiUsageMetadata{
|
||||
PromptTokenCount: 2,
|
||||
CandidatesTokenCount: 3,
|
||||
TotalTokenCount: 5,
|
||||
},
|
||||
}
|
||||
body, err := common.Marshal(payload)
|
||||
require.NoError(t, err)
|
||||
|
||||
usage, newAPIError := adaptor.DoResponse(c, &http.Response{
|
||||
Body: io.NopCloser(bytes.NewReader(body)),
|
||||
}, info)
|
||||
require.Nil(t, newAPIError)
|
||||
require.NotNil(t, usage)
|
||||
|
||||
got := recorder.Body.String()
|
||||
assert.Contains(t, got, `"object":"response"`)
|
||||
assert.Contains(t, got, `"type":"output_text"`)
|
||||
assert.Contains(t, got, `"text":"hello"`)
|
||||
assert.NotContains(t, got, `"candidates"`)
|
||||
}
|
||||
|
||||
func TestAdaptorResponsesToGeminiAddsThoughtSignatureForFunctionCallHistory(t *testing.T) {
|
||||
geminiSettings := model_setting.GetGeminiSettings()
|
||||
originalThoughtSignatureEnabled := geminiSettings.FunctionCallThoughtSignatureEnabled
|
||||
geminiSettings.FunctionCallThoughtSignatureEnabled = true
|
||||
t.Cleanup(func() {
|
||||
geminiSettings.FunctionCallThoughtSignatureEnabled = originalThoughtSignatureEnabled
|
||||
})
|
||||
|
||||
adaptor := &Adaptor{}
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1/responses",
|
||||
UpstreamPath: "/v1beta/models/{model}:generateContent",
|
||||
Converter: relayconvert.ConverterOpenAIResponsesToGemini,
|
||||
Models: []string{"gemini-test"},
|
||||
},
|
||||
},
|
||||
})
|
||||
info.RelayFormat = types.RelayFormatOpenAIResponses
|
||||
info.RelayMode = relayconstant.RelayModeResponses
|
||||
info.RequestURLPath = "/v1/responses"
|
||||
info.OriginModelName = "gemini-test"
|
||||
info.UpstreamModelName = "gemini-test"
|
||||
|
||||
converted, err := adaptor.ConvertOpenAIResponsesRequest(advancedCustomGinContext("/v1/responses"), info, dto.OpenAIResponsesRequest{
|
||||
Model: "gemini-test",
|
||||
Input: mustAdvancedCustomRawMessage(t, []map[string]any{
|
||||
{
|
||||
"role": "user",
|
||||
"content": "hi",
|
||||
},
|
||||
{
|
||||
"type": "function_call",
|
||||
"call_id": "call_1",
|
||||
"name": "glob",
|
||||
"arguments": map[string]any{"query": "*"},
|
||||
},
|
||||
{
|
||||
"type": "function_call_output",
|
||||
"call_id": "call_1",
|
||||
"output": []map[string]any{{"path": "report.md"}},
|
||||
},
|
||||
}),
|
||||
Tools: mustAdvancedCustomRawMessage(t, []map[string]any{
|
||||
{"type": "function", "name": "glob", "parameters": map[string]any{"type": "object"}},
|
||||
}),
|
||||
})
|
||||
require.NoError(t, err)
|
||||
|
||||
geminiReq, ok := converted.(*dto.GeminiChatRequest)
|
||||
require.True(t, ok)
|
||||
require.Len(t, geminiReq.Contents, 3)
|
||||
require.Len(t, geminiReq.Contents[1].Parts, 1)
|
||||
require.NotNil(t, geminiReq.Contents[1].Parts[0].FunctionCall)
|
||||
assert.NotEmpty(t, geminiReq.Contents[1].Parts[0].ThoughtSignature)
|
||||
require.Len(t, geminiReq.Contents[2].Parts, 1)
|
||||
require.NotNil(t, geminiReq.Contents[2].Parts[0].FunctionResponse)
|
||||
assert.Empty(t, geminiReq.Contents[2].Parts[0].ThoughtSignature)
|
||||
}
|
||||
|
||||
func TestAdaptorConvertsOpenAIChatRequestToResponsesUpstream(t *testing.T) {
|
||||
adaptor := &Adaptor{}
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1/chat/completions",
|
||||
UpstreamPath: "/v1/responses",
|
||||
Converter: relayconvert.ConverterOpenAIChatToOpenAIResponses,
|
||||
},
|
||||
},
|
||||
})
|
||||
c := advancedCustomGinContext("/v1/chat/completions")
|
||||
|
||||
converted, err := adaptor.ConvertOpenAIRequest(c, info, &dto.GeneralOpenAIRequest{
|
||||
Model: "gpt-test",
|
||||
Messages: []dto.Message{
|
||||
{Role: "user", Content: "hello"},
|
||||
},
|
||||
})
|
||||
require.NoError(t, err)
|
||||
|
||||
responsesReq, ok := converted.(*dto.OpenAIResponsesRequest)
|
||||
require.True(t, ok)
|
||||
assert.Equal(t, "gpt-test", responsesReq.Model)
|
||||
assert.NotEmpty(t, responsesReq.Input)
|
||||
}
|
||||
|
||||
func TestAdaptorConvertsOpenAIChatRequestToClaudeUpstream(t *testing.T) {
|
||||
adaptor := &Adaptor{}
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1/chat/completions",
|
||||
UpstreamPath: "/v1/messages",
|
||||
Converter: relayconvert.ConverterOpenAIChatToClaudeMessages,
|
||||
},
|
||||
},
|
||||
})
|
||||
c := advancedCustomGinContext("/v1/chat/completions")
|
||||
|
||||
converted, err := adaptor.ConvertOpenAIRequest(c, info, &dto.GeneralOpenAIRequest{
|
||||
Model: "claude-test",
|
||||
Messages: []dto.Message{
|
||||
{Role: "user", Content: "hello"},
|
||||
},
|
||||
})
|
||||
require.NoError(t, err)
|
||||
|
||||
claudeReq, ok := converted.(*dto.ClaudeRequest)
|
||||
require.True(t, ok)
|
||||
assert.Equal(t, "claude-test", claudeReq.Model)
|
||||
require.Len(t, claudeReq.Messages, 1)
|
||||
assert.Equal(t, "user", claudeReq.Messages[0].Role)
|
||||
}
|
||||
|
||||
func TestAdaptorConvertsOpenAIChatRequestToGeminiUpstream(t *testing.T) {
|
||||
adaptor := &Adaptor{}
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1/chat/completions",
|
||||
UpstreamPath: "/v1beta/models/{model}:generateContent",
|
||||
Converter: relayconvert.ConverterOpenAIChatToGeminiContent,
|
||||
},
|
||||
},
|
||||
})
|
||||
info.UpstreamModelName = "gemini-2.5-flash"
|
||||
c := advancedCustomGinContext("/v1/chat/completions")
|
||||
|
||||
converted, err := adaptor.ConvertOpenAIRequest(c, info, &dto.GeneralOpenAIRequest{
|
||||
Model: "gemini-2.5-flash",
|
||||
Messages: []dto.Message{
|
||||
{Role: "user", Content: "hello"},
|
||||
},
|
||||
})
|
||||
require.NoError(t, err)
|
||||
|
||||
geminiReq, ok := converted.(*dto.GeminiChatRequest)
|
||||
require.True(t, ok)
|
||||
require.Len(t, geminiReq.Contents, 1)
|
||||
assert.Equal(t, "user", geminiReq.Contents[0].Role)
|
||||
}
|
||||
|
||||
func TestAdaptorConvertsClaudeRequestToOpenAIChatUpstream(t *testing.T) {
|
||||
adaptor := &Adaptor{}
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1/messages",
|
||||
UpstreamPath: "/v1/chat/completions",
|
||||
Converter: relayconvert.ConverterClaudeMessagesToOpenAIChat,
|
||||
},
|
||||
},
|
||||
})
|
||||
info.RelayFormat = types.RelayFormatClaude
|
||||
info.RequestURLPath = "/v1/messages"
|
||||
c := advancedCustomGinContext("/v1/messages")
|
||||
|
||||
converted, err := adaptor.ConvertClaudeRequest(c, info, &dto.ClaudeRequest{
|
||||
Model: "gpt-test",
|
||||
Messages: []dto.ClaudeMessage{
|
||||
{Role: "user", Content: "hello"},
|
||||
},
|
||||
})
|
||||
require.NoError(t, err)
|
||||
|
||||
chatReq, ok := converted.(*dto.GeneralOpenAIRequest)
|
||||
require.True(t, ok)
|
||||
assert.Equal(t, "gpt-test", chatReq.Model)
|
||||
require.Len(t, chatReq.Messages, 1)
|
||||
assert.Equal(t, "user", chatReq.Messages[0].Role)
|
||||
}
|
||||
|
||||
func TestAdaptorConvertsGeminiRequestToOpenAIChatUpstream(t *testing.T) {
|
||||
adaptor := &Adaptor{}
|
||||
info := advancedCustomRelayInfo(&dto.AdvancedCustomConfig{
|
||||
Routes: []dto.AdvancedCustomRoute{
|
||||
{
|
||||
IncomingPath: "/v1beta/models/{model}:generateContent",
|
||||
UpstreamPath: "/v1/chat/completions",
|
||||
Converter: relayconvert.ConverterGeminiContentToOpenAIChat,
|
||||
},
|
||||
},
|
||||
})
|
||||
info.RelayFormat = types.RelayFormatGemini
|
||||
info.RequestURLPath = "/v1beta/models/gemini-2.5-flash:generateContent"
|
||||
info.UpstreamModelName = "gpt-test"
|
||||
c := advancedCustomGinContext("/v1beta/models/gemini-2.5-flash:generateContent")
|
||||
|
||||
converted, err := adaptor.ConvertGeminiRequest(c, info, &dto.GeminiChatRequest{
|
||||
Contents: []dto.GeminiChatContent{
|
||||
{
|
||||
Role: "user",
|
||||
Parts: []dto.GeminiPart{
|
||||
{Text: "hello"},
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
require.NoError(t, err)
|
||||
|
||||
chatReq, ok := converted.(*dto.GeneralOpenAIRequest)
|
||||
require.True(t, ok)
|
||||
assert.Equal(t, "gpt-test", chatReq.Model)
|
||||
require.Len(t, chatReq.Messages, 1)
|
||||
assert.Equal(t, "user", chatReq.Messages[0].Role)
|
||||
}
|
||||
|
||||
func advancedCustomRelayInfo(config *dto.AdvancedCustomConfig) *relaycommon.RelayInfo {
|
||||
return &relaycommon.RelayInfo{
|
||||
RelayFormat: types.RelayFormatOpenAI,
|
||||
RelayMode: relayconstant.RelayModeChatCompletions,
|
||||
RequestURLPath: "/v1/chat/completions",
|
||||
OriginModelName: "gpt-test",
|
||||
ChannelMeta: &relaycommon.ChannelMeta{
|
||||
ApiKey: "sk-test",
|
||||
ChannelBaseUrl: "https://fallback.example",
|
||||
ChannelType: constant.ChannelTypeAdvancedCustom,
|
||||
UpstreamModelName: "gpt-test",
|
||||
ChannelOtherSettings: dto.ChannelOtherSettings{
|
||||
AdvancedCustom: config,
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func advancedCustomGinContext(path string) *gin.Context {
|
||||
gin.SetMode(gin.TestMode)
|
||||
c, _ := gin.CreateTestContext(httptest.NewRecorder())
|
||||
c.Request = httptest.NewRequest(http.MethodPost, path, nil)
|
||||
c.Request.Header.Set("Content-Type", "application/json")
|
||||
return c
|
||||
}
|
||||
|
||||
func mustAdvancedCustomRawMessage(t *testing.T, value any) []byte {
|
||||
t.Helper()
|
||||
raw, err := common.Marshal(value)
|
||||
require.NoError(t, err)
|
||||
return raw
|
||||
}
|
||||
Reference in New Issue
Block a user