Skip to content

phsl / new-api

Go to a project
Commit d52505ca by feitianbubu
Options

feat: opt minimax tts req struct

parent a2d34b9e
Showing with 90 additions and 106 deletions
relay/channel/minimax/adaptor.go
...@@ -34,17 +34,20 @@ func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInf ...@@ -34,17 +34,20 @@ func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInf
return nil, errors.New("unsupported audio relay mode") return nil, errors.New("unsupported audio relay mode")
} }
voiceID := mapVoiceType(request.Voice) voiceID := request.Voice
speed := request.Speed speed := request.Speed
outputFormat := mapOutputFormat(request.ResponseFormat) outputFormat := request.ResponseFormat
c.Set("response_format", outputFormat)
minimaxRequest := MiniMaxTTSRequest{ minimaxRequest := MiniMaxTTSRequest{
Model: getTTSModel(info.OriginModelName), Model: info.OriginModelName,
Text: request.Input, Text: request.Input,
VoiceSetting: VoiceSetting{
VoiceID: voiceID, VoiceID: voiceID,
Speed: speed, Speed: speed,
},
AudioSetting: &AudioSetting{
Format: outputFormat,
},
OutputFormat: outputFormat, OutputFormat: outputFormat,
} }
...@@ -59,6 +62,11 @@ func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInf ...@@ -59,6 +62,11 @@ func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInf
if err != nil { if err != nil {
return nil, fmt.Errorf("error marshalling minimax request: %w", err) return nil, fmt.Errorf("error marshalling minimax request: %w", err)
} }
if outputFormat != "hex" {
outputFormat = "url"
}
c.Set("response_format", outputFormat)
// Debug: log the request structure // Debug: log the request structure
fmt.Printf("MiniMax TTS Request: %s\n", string(jsonData)) fmt.Printf("MiniMax TTS Request: %s\n", string(jsonData))
...@@ -79,12 +87,6 @@ func (a *Adaptor) GetRequestURL(info *relaycommon.RelayInfo) (string, error) { ...@@ -79,12 +87,6 @@ func (a *Adaptor) GetRequestURL(info *relaycommon.RelayInfo) (string, error) {
func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *relaycommon.RelayInfo) error { func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *relaycommon.RelayInfo) error {
channel.SetupApiRequestHeader(info, c, req) channel.SetupApiRequestHeader(info, c, req)
if info.RelayMode == constant.RelayModeAudioSpeech {
req.Set("Content-Type", "application/json")
return nil
}
req.Set("Authorization", "Bearer "+info.ApiKey) req.Set("Authorization", "Bearer "+info.ApiKey)
return nil return nil
} }
......
relay/channel/minimax/tts.go
package minimax package minimax
import ( import (
"encoding/base64" "encoding/hex"
"encoding/json" "encoding/json"
"errors" "errors"
"fmt"
"io" "io"
"net/http" "net/http"
"strings"
"github.com/QuantumNous/new-api/dto" "github.com/QuantumNous/new-api/dto"
relaycommon "github.com/QuantumNous/new-api/relay/common" relaycommon "github.com/QuantumNous/new-api/relay/common"
...@@ -16,94 +18,76 @@ import ( ...@@ -16,94 +18,76 @@ import (
type MiniMaxTTSRequest struct { type MiniMaxTTSRequest struct {
Model string `json:"model"` Model string `json:"model"`
Text string `json:"text"` Text string `json:"text"`
VoiceID string `json:"voice_id"` Stream bool `json:"stream,omitempty"`
Speed float64 `json:"speed,omitempty"` StreamOptions *StreamOptions `json:"stream_options,omitempty"`
Vol float64 `json:"vol,omitempty"` VoiceSetting VoiceSetting `json:"voice_setting"`
Pitch int `json:"pitch,omitempty"` PronunciationDict *PronunciationDict `json:"pronunciation_dict,omitempty"`
AudioSampleRate int `json:"audio_sample_rate,omitempty"` AudioSetting *AudioSetting `json:"audio_setting,omitempty"`
TimbreWeights []TimbreWeight `json:"timbre_weights,omitempty"`
LanguageBoost string `json:"language_boost,omitempty"`
VoiceModify *VoiceModify `json:"voice_modify,omitempty"`
SubtitleEnable bool `json:"subtitle_enable,omitempty"`
OutputFormat string `json:"output_format,omitempty"` OutputFormat string `json:"output_format,omitempty"`
AigcWatermark bool `json:"aigc_watermark,omitempty"`
} }
type MiniMaxTTSResponse struct { type StreamOptions struct {
Created int `json:"created"` ExcludeAggregatedAudio bool `json:"exclude_aggregated_audio,omitempty"`
Data []MiniMaxTTSData `json:"data"`
ID string `json:"id"`
Model string `json:"model"`
Object string `json:"object"`
Usage MiniMaxTTSUsage `json:"usage"`
}
type MiniMaxTTSData struct {
Index int `json:"index"`
Audio string `json:"audio"`
Text string `json:"text"`
FinishReason string `json:"finish_reason"`
} }
type MiniMaxTTSUsage struct { type VoiceSetting struct {
TotalTokens int `json:"total_tokens"` VoiceID string `json:"voice_id"`
Speed float64 `json:"speed,omitempty"`
Vol float64 `json:"vol,omitempty"`
Pitch int `json:"pitch,omitempty"`
Emotion string `json:"emotion,omitempty"`
TextNormalization bool `json:"text_normalization,omitempty"`
LatexRead bool `json:"latex_read,omitempty"`
} }
type MiniMaxTTSErrorResponse struct { type PronunciationDict struct {
Error MiniMaxTTSError `json:"error"` Tone []string `json:"tone,omitempty"`
} }
type MiniMaxTTSError struct { type AudioSetting struct {
Code string `json:"code"` SampleRate int `json:"sample_rate,omitempty"`
Message string `json:"message"` Bitrate int `json:"bitrate,omitempty"`
Type string `json:"type"` Format string `json:"format,omitempty"`
Channel int `json:"channel,omitempty"`
ForceCbr bool `json:"force_cbr,omitempty"`
} }
// OpenAI voice to MiniMax voice_id mapping type TimbreWeight struct {
var openAIToMiniMaxVoiceMap = map[string]string{ VoiceID string `json:"voice_id"`
"alloy": "male-qn-qingse", Weight int `json:"weight"`
"echo": "male-qn-jingying",
"fable": "female-shaonv",
"onyx": "male-qn-badao",
"nova": "female-shaonv-jingpin",
"shimmer": "female-yujie",
// Add some standard MiniMax voice IDs
"voice-1": "male-qn-qingse",
"voice-2": "female-shaonv",
} }
// OpenAI response format to MiniMax output format mapping type VoiceModify struct {
var responseFormatToOutputFormatMap = map[string]string{ Pitch int `json:"pitch,omitempty"`
"mp3": "mp3", Intensity int `json:"intensity,omitempty"`
"opus": "mp3", Timbre int `json:"timbre,omitempty"`
"aac": "aac", SoundEffects string `json:"sound_effects,omitempty"`
"flac": "flac",
"wav": "wav",
"pcm": "pcm",
} }
// TTS model mapping - MiniMax uses speech-01 or speech-01-turbo type MiniMaxTTSResponse struct {
var modelToTTSModelMap = map[string]string{ Data MiniMaxTTSData `json:"data"`
"speech-01": "speech-01", ExtraInfo MiniMaxExtraInfo `json:"extra_info"`
"speech-01-turbo": "speech-01-turbo", TraceID string `json:"trace_id"`
"tts-1": "speech-01-turbo", BaseResp MiniMaxBaseResp `json:"base_resp"`
"tts-1-hd": "speech-01",
} }
func mapVoiceType(openAIVoice string) string { type MiniMaxTTSData struct {
if voice, ok := openAIToMiniMaxVoiceMap[openAIVoice]; ok { Audio string `json:"audio"`
return voice Status int `json:"status"`
}
return "female-shaonv" // default voice
} }
func mapOutputFormat(responseFormat string) string { type MiniMaxExtraInfo struct {
if format, ok := responseFormatToOutputFormatMap[responseFormat]; ok { UsageCharacters int64 `json:"usage_characters"`
return format
}
return "mp3" // default format
} }
func getTTSModel(modelName string) string { type MiniMaxBaseResp struct {
if ttsModel, ok := modelToTTSModelMap[modelName]; ok { StatusCode int64 `json:"status_code"`
return ttsModel StatusMsg string `json:"status_msg"`
}
return "speech-01-turbo" // default model
} }
func getContentTypeByFormat(format string) string { func getContentTypeByFormat(format string) string {
...@@ -124,66 +108,64 @@ func handleTTSResponse(c *gin.Context, resp *http.Response, info *relaycommon.Re ...@@ -124,66 +108,64 @@ func handleTTSResponse(c *gin.Context, resp *http.Response, info *relaycommon.Re
body, readErr := io.ReadAll(resp.Body) body, readErr := io.ReadAll(resp.Body)
if readErr != nil { if readErr != nil {
return nil, types.NewErrorWithStatusCode( return nil, types.NewErrorWithStatusCode(
errors.New("failed to read minimax response"), fmt.Errorf("failed to read minimax response: %w", readErr),
types.ErrorCodeReadResponseBodyFailed, types.ErrorCodeReadResponseBodyFailed,
http.StatusInternalServerError, http.StatusInternalServerError,
) )
} }
defer resp.Body.Close() defer resp.Body.Close()
// First try to parse as error response // Parse response
var errorResp MiniMaxTTSErrorResponse
if unmarshalErr := json.Unmarshal(body, &errorResp); unmarshalErr == nil && errorResp.Error.Code != "" {
return nil, types.NewErrorWithStatusCode(
errors.New(errorResp.Error.Message),
types.ErrorCodeBadResponse,
http.StatusBadRequest,
)
}
// Parse as successful response
var minimaxResp MiniMaxTTSResponse var minimaxResp MiniMaxTTSResponse
if unmarshalErr := json.Unmarshal(body, &minimaxResp); unmarshalErr != nil { if unmarshalErr := json.Unmarshal(body, &minimaxResp); unmarshalErr != nil {
return nil, types.NewErrorWithStatusCode( return nil, types.NewErrorWithStatusCode(
errors.New("failed to parse minimax response"), fmt.Errorf("failed to unmarshal minimax TTS response: %w", unmarshalErr),
types.ErrorCodeBadResponseBody, types.ErrorCodeBadResponseBody,
http.StatusInternalServerError, http.StatusInternalServerError,
) )
} }
// Check base_resp status code
if minimaxResp.BaseResp.StatusCode != 0 {
return nil, types.NewErrorWithStatusCode(
fmt.Errorf("minimax TTS error: %d - %s", minimaxResp.BaseResp.StatusCode, minimaxResp.BaseResp.StatusMsg),
types.ErrorCodeBadResponse,
http.StatusBadRequest,
)
}
// Check if we have audio data // Check if we have audio data
if len(minimaxResp.Data) == 0 || minimaxResp.Data[0].Audio == "" { if minimaxResp.Data.Audio == "" {
return nil, types.NewErrorWithStatusCode( return nil, types.NewErrorWithStatusCode(
errors.New("no audio data in response"), fmt.Errorf("no audio data in minimax TTS response"),
types.ErrorCodeBadResponse, types.ErrorCodeBadResponse,
http.StatusBadRequest, http.StatusBadRequest,
) )
} }
// Decode base64 audio data if strings.HasPrefix(minimaxResp.Data.Audio, "http") {
audioData, decodeErr := base64.StdEncoding.DecodeString(minimaxResp.Data[0].Audio) c.Redirect(http.StatusFound, minimaxResp.Data.Audio)
} else {
// Handle hex-encoded audio data
audioData, decodeErr := hex.DecodeString(minimaxResp.Data.Audio)
if decodeErr != nil { if decodeErr != nil {
return nil, types.NewErrorWithStatusCode( return nil, types.NewErrorWithStatusCode(
errors.New("failed to decode audio data"), fmt.Errorf("failed to decode hex audio data: %w", decodeErr),
types.ErrorCodeBadResponseBody, types.ErrorCodeBadResponse,
http.StatusInternalServerError, http.StatusInternalServerError,
) )
} }
// Get output format from context or default to mp3 // Determine content type - default to mp3
outputFormat := c.GetString("response_format") contentType := "audio/mpeg"
if outputFormat == "" {
outputFormat = "mp3"
}
contentType := getContentTypeByFormat(outputFormat)
c.Header("Content-Type", contentType)
c.Data(http.StatusOK, contentType, audioData) c.Data(http.StatusOK, contentType, audioData)
}
usage = &dto.Usage{ usage = &dto.Usage{
PromptTokens: info.PromptTokens, PromptTokens: info.PromptTokens,
CompletionTokens: 0, CompletionTokens: 0,
TotalTokens: minimaxResp.Usage.TotalTokens, TotalTokens: int(minimaxResp.ExtraInfo.UsageCharacters),
} }
return usage, nil return usage, nil
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment