6748b006b7
This commit refactors the logging mechanism across the application by replacing direct logger calls with a centralized logging approach using the `common` package. Key changes include: - Replaced instances of `logger.SysLog` and `logger.FatalLog` with `common.SysLog` and `common.FatalLog` for consistent logging practices. - Updated resource initialization error handling to utilize the new logging structure, enhancing maintainability and readability. - Minor adjustments to improve code clarity and organization throughout various modules. This change aims to streamline logging and improve the overall architecture of the codebase.
134 lines
4.1 KiB
Go
134 lines
4.1 KiB
Go
package xai
|
|
|
|
import (
|
|
"errors"
|
|
"io"
|
|
"net/http"
|
|
"one-api/dto"
|
|
"one-api/relay/channel"
|
|
"one-api/relay/channel/openai"
|
|
relaycommon "one-api/relay/common"
|
|
"one-api/types"
|
|
"strings"
|
|
|
|
"one-api/relay/constant"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
type Adaptor struct {
|
|
}
|
|
|
|
func (a *Adaptor) ConvertGeminiRequest(*gin.Context, *relaycommon.RelayInfo, *dto.GeminiChatRequest) (any, error) {
|
|
//TODO implement me
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (a *Adaptor) ConvertClaudeRequest(*gin.Context, *relaycommon.RelayInfo, *dto.ClaudeRequest) (any, error) {
|
|
//TODO implement me
|
|
//panic("implement me")
|
|
return nil, errors.New("not available")
|
|
}
|
|
|
|
func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
|
|
//not available
|
|
return nil, errors.New("not available")
|
|
}
|
|
|
|
func (a *Adaptor) ConvertImageRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.ImageRequest) (any, error) {
|
|
xaiRequest := ImageRequest{
|
|
Model: request.Model,
|
|
Prompt: request.Prompt,
|
|
N: int(request.N),
|
|
ResponseFormat: request.ResponseFormat,
|
|
}
|
|
return xaiRequest, nil
|
|
}
|
|
|
|
func (a *Adaptor) Init(info *relaycommon.RelayInfo) {
|
|
}
|
|
|
|
func (a *Adaptor) GetRequestURL(info *relaycommon.RelayInfo) (string, error) {
|
|
return relaycommon.GetFullRequestURL(info.ChannelBaseUrl, info.RequestURLPath, info.ChannelType), nil
|
|
}
|
|
|
|
func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *relaycommon.RelayInfo) error {
|
|
channel.SetupApiRequestHeader(info, c, req)
|
|
req.Set("Authorization", "Bearer "+info.ApiKey)
|
|
return nil
|
|
}
|
|
|
|
func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
|
|
if request == nil {
|
|
return nil, errors.New("request is nil")
|
|
}
|
|
if strings.HasSuffix(info.UpstreamModelName, "-search") {
|
|
info.UpstreamModelName = strings.TrimSuffix(info.UpstreamModelName, "-search")
|
|
request.Model = info.UpstreamModelName
|
|
toMap := request.ToMap()
|
|
toMap["search_parameters"] = map[string]any{
|
|
"mode": "on",
|
|
}
|
|
return toMap, nil
|
|
}
|
|
if strings.HasPrefix(request.Model, "grok-3-mini") {
|
|
if request.MaxCompletionTokens == 0 && request.MaxTokens != 0 {
|
|
request.MaxCompletionTokens = request.MaxTokens
|
|
request.MaxTokens = 0
|
|
}
|
|
if strings.HasSuffix(request.Model, "-high") {
|
|
request.ReasoningEffort = "high"
|
|
request.Model = strings.TrimSuffix(request.Model, "-high")
|
|
} else if strings.HasSuffix(request.Model, "-low") {
|
|
request.ReasoningEffort = "low"
|
|
request.Model = strings.TrimSuffix(request.Model, "-low")
|
|
} else if strings.HasSuffix(request.Model, "-medium") {
|
|
request.ReasoningEffort = "medium"
|
|
request.Model = strings.TrimSuffix(request.Model, "-medium")
|
|
}
|
|
info.ReasoningEffort = request.ReasoningEffort
|
|
info.UpstreamModelName = request.Model
|
|
}
|
|
return request, nil
|
|
}
|
|
|
|
func (a *Adaptor) ConvertRerankRequest(c *gin.Context, relayMode int, request dto.RerankRequest) (any, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (a *Adaptor) ConvertEmbeddingRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.EmbeddingRequest) (any, error) {
|
|
//not available
|
|
return nil, errors.New("not available")
|
|
}
|
|
|
|
func (a *Adaptor) ConvertOpenAIResponsesRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.OpenAIResponsesRequest) (any, error) {
|
|
// TODO implement me
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, requestBody io.Reader) (any, error) {
|
|
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) {
|
|
switch info.RelayMode {
|
|
case constant.RelayModeImagesGenerations, constant.RelayModeImagesEdits:
|
|
usage, err = openai.OpenaiHandlerWithUsage(c, info, resp)
|
|
default:
|
|
if info.IsStream {
|
|
usage, err = xAIStreamHandler(c, info, resp)
|
|
} else {
|
|
usage, err = xAIHandler(c, info, resp)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func (a *Adaptor) GetModelList() []string {
|
|
return ModelList
|
|
}
|
|
|
|
func (a *Adaptor) GetChannelName() string {
|
|
return ChannelName
|
|
}
|