feat(voice): 百炼声音复刻create_voice + TTS instruction情绪驱动(主TTS-昔涟复刻音色)

internal/runtime/multimodal/voice/dashscope.go

@@ -9,6 +9,7 @@ import (
 	"io"
 	"net/http"
 	"strings"
+	"unicode"
 
 	"git.yeij.top/AskaEth/Cyrene_v2/internal/config"
 )
@@ -33,8 +34,14 @@ const (
 	dashscopeSTTPath = "/services/aigc/multimodal-generation/generation"
 	// dashscopeTTSPath is the SpeechSynthesizer service path (TTS).
 	dashscopeTTSPath = "/services/audio/tts/SpeechSynthesizer"
+	// dashscopeClonePath is the voice-customization (声音复刻 create_voice) path.
+	dashscopeClonePath = "/services/audio/tts/customization"
 	// defaultDashscopeBaseURL is the Bailian API root when none is configured.
 	defaultDashscopeBaseURL = "https://dashscope.aliyuncs.com/api/v1"
+	// defaultClonePrefix is the voice-name prefix when none is supplied.
+	defaultClonePrefix = "cyrene"
+	// voiceEnrollmentModel is the DashScope voice-enrollment model ("create_voice").
+	voiceEnrollmentModel = "voice-enrollment"
 )
 
 // DashscopeSTT transcribes audio via DashScope multimodal-generation.
@@ -114,13 +121,14 @@ func (s *DashscopeSTT) STT(ctx context.Context, audio Audio) (string, error) {
 
 // DashscopeTTS synthesizes speech video via DashScope SpeechSynthesizer.
 type DashscopeTTS struct {
-	endpoint   string
-	apiKey     string
-	model      string
-	voiceID    string
-	format     string
-	sampleRate int
-	client     *http.Client
+	endpoint    string
+	apiKey      string
+	model       string
+	voiceID     string
+	format      string
+	sampleRate  int
+	instruction string
+	client      *http.Client
 }
 
 // NewDashscopeTTS builds the DashScope TTS adapter from cfg. Missing model /
@@ -134,13 +142,14 @@ func NewDashscopeTTS(cfg config.VoiceConfig) *DashscopeTTS {
 		sampleRate = 24000
 	}
 	return &DashscopeTTS{
-		endpoint:   dashscopeEndpoint(cfg.DashscopeBaseURL) + dashscopeTTSPath,
-		apiKey:     cfg.DashscopeAPIKey,
-		model:      model,
-		voiceID:    voiceID,
-		format:     format,
-		sampleRate: sampleRate,
-		client:     defaultHTTPClient(),
+		endpoint:    dashscopeEndpoint(cfg.DashscopeBaseURL) + dashscopeTTSPath,
+		apiKey:      cfg.DashscopeAPIKey,
+		model:       model,
+		voiceID:     voiceID,
+		format:      format,
+		sampleRate:  sampleRate,
+		instruction: cfg.VoiceTTSInstruction,
+		client:      defaultHTTPClient(),
 	}
 }
 
@@ -157,7 +166,7 @@ func (t *DashscopeTTS) TTS(ctx context.Context, text string) (Audio, error) {
 	if err := ctx.Err(); err != nil {
 		return Audio{}, err
 	}
-	payload, err := json.Marshal(dashscopeTTSRequest{
+	req := dashscopeTTSRequest{
 		Model: t.model,
 		Input: dashscopeTTSInput{
 			Text:       text,
@@ -165,7 +174,11 @@ func (t *DashscopeTTS) TTS(ctx context.Context, text string) (Audio, error) {
 			Format:     t.format,
 			SampleRate: t.sampleRate,
 		},
-	})
+	}
+	if instruction := t.EffectiveInstruction(ctx); instruction != "" {
+		req.Input.Instruction = instruction
+	}
+	payload, err := json.Marshal(req)
 	if err != nil {
 		return Audio{}, fmt.Errorf("voice: %w: marshal: %v", ErrProviderFailed, err)
 	}
@@ -181,6 +194,29 @@ func (t *DashscopeTTS) TTS(ctx context.Context, text string) (Audio, error) {
 	return Audio{Format: t.format, Data: data}, nil
 }
 
+// EffectiveInstruction returns the instruction to send for this synthesis: a
+// per-request override threaded through ctx wins, else the configured default. An
+// empty result means the request carries no instruction. A system voice never gets
+// a free-form instruction (see canInstruct), because cosyvoice v3 system voices
+// require a fixed instruction format.
+func (t *DashscopeTTS) EffectiveInstruction(ctx context.Context) string {
+	if !canInstruct(t.voiceID) {
+		return ""
+	}
+	if override := TTSInstructionFromContext(ctx); override != "" {
+		return override
+	}
+	return t.instruction
+}
+
+// canInstruct reports whether voiceID accepts a free-form instruction. cosyvoice v3
+// system voices (the long*_v3 family, e.g. longxiaochun_v3) require a fixed
+// instruction format; a cloned/designed voice (声音复刻, whose id never ends in
+// "_v3") accepts an arbitrary instruction.
+func canInstruct(voiceID string) bool {
+	return !strings.HasSuffix(voiceID, "_v3")
+}
+
 // audioBytes resolves the synthesized audio from the DashScope response: a 24h
 // URL is downloaded, or an inline base64 blob is decoded.
 func (t *DashscopeTTS) audioBytes(ctx context.Context, body []byte) ([]byte, error) {
@@ -227,6 +263,95 @@ func (t *DashscopeTTS) download(ctx context.Context, url string) ([]byte, error)
 	return data, nil
 }
 
+// DashscopeCloner creates custom TTS voices via the DashScope voice-enrollment
+// API (声音复刻 create_voice). The reference audio must be a public URL — the
+// create_voice action only accepts input.url (no base64). The returned voice_id is
+// bound to TTSModel, so target_model must match the model used at synthesis time.
+type DashscopeCloner struct {
+	endpoint string
+	apiKey   string
+	model    string
+	client   *http.Client
+}
+
+// NewDashscopeCloner builds the DashScope voice cloner from cfg. Missing model /
+// base URL fall back to the DashScope defaults; the model tracks TTSModel so the
+// cloned voice is usable by the TTS rung (target_model must match).
+func NewDashscopeCloner(cfg config.VoiceConfig) *DashscopeCloner {
+	return &DashscopeCloner{
+		endpoint: dashscopeEndpoint(cfg.DashscopeBaseURL) + dashscopeClonePath,
+		apiKey:   cfg.DashscopeAPIKey,
+		model:    firstNonEmpty(cfg.TTSModel, "cosyvoice-v3-flash"),
+		client:   defaultHTTPClient(),
+	}
+}
+
+// CloneVoice submits a create_voice request and returns the created voice_id. It
+// is the adapter behind the REST /api/v1/audio/voice-clone endpoint. A missing API
+// key returns ErrNotConfigured; an empty URL or an invalid prefix is rejected.
+func (d *DashscopeCloner) CloneVoice(ctx context.Context, referenceURL, prefix string) (string, error) {
+	if d.apiKey == "" {
+		return "", ErrNotConfigured
+	}
+	referenceURL = strings.TrimSpace(referenceURL)
+	if referenceURL == "" {
+		return "", fmt.Errorf("voice: %w: reference audio url is required", ErrProviderFailed)
+	}
+	prefix, err := normalizeClonePrefix(prefix)
+	if err != nil {
+		return "", err
+	}
+	if err := ctx.Err(); err != nil {
+		return "", err
+	}
+	payload, err := json.Marshal(dashscopeCloneRequest{
+		Model: voiceEnrollmentModel,
+		Input: dashscopeCloneInput{
+			Action:      "create_voice",
+			TargetModel: d.model,
+			Prefix:      prefix,
+			URL:         referenceURL,
+		},
+	})
+	if err != nil {
+		return "", fmt.Errorf("voice: %w: marshal: %v", ErrProviderFailed, err)
+	}
+	body, err := dashscopePost(ctx, d.client, d.apiKey, d.endpoint, payload, "")
+	if err != nil {
+		return "", err
+	}
+	var resp dashscopeCloneResponse
+	if err := json.Unmarshal(body, &resp); err != nil {
+		return "", fmt.Errorf("voice: %w: decode: %v", ErrProviderFailed, err)
+	}
+	if resp.Message != "" {
+		return "", fmt.Errorf("voice: %w: %s", ErrProviderFailed, resp.Message)
+	}
+	if resp.Output.VoiceID == "" {
+		return "", fmt.Errorf("voice: %w: no voice_id in response", ErrProviderFailed)
+	}
+	return resp.Output.VoiceID, nil
+}
+
+// normalizeClonePrefix trims and validates the voice-name prefix. An empty value
+// falls back to defaultClonePrefix; the result must be ≤10 letter/digit chars
+// (the voice-enrollment prefix constraint).
+func normalizeClonePrefix(prefix string) (string, error) {
+	prefix = strings.TrimSpace(prefix)
+	if prefix == "" {
+		return defaultClonePrefix, nil
+	}
+	if len(prefix) > 10 {
+		return "", fmt.Errorf("voice: %w: prefix %q exceeds 10 chars", ErrProviderFailed, prefix)
+	}
+	for _, r := range prefix {
+		if !unicode.IsLetter(r) && !unicode.IsDigit(r) {
+			return "", fmt.Errorf("voice: %w: prefix must be alphanumeric", ErrProviderFailed)
+		}
+	}
+	return prefix, nil
+}
+
 // dashscopeEndpoint returns the DashScope API base with a trailing slash trimmed,
 // defaulting to the public Bailian root when none is configured.
 func dashscopeEndpoint(baseURL string) string {
@@ -394,4 +519,30 @@ type dashscopeTTSInput struct {
 	Voice      string `json:"voice"`
 	Format     string `json:"format"`
 	SampleRate int    `json:"sample_rate"`
+	// Instruction is the CosyVoice emotion/tone instruction; omitempty keeps a
+	// system voice (which must use a fixed instruction) free of a free-form one.
+	Instruction string `json:"instruction,omitempty"`
+}
+
+// dashscopeCloneRequest is the voice-enrollment create_voice request body.
+type dashscopeCloneRequest struct {
+	Model string              `json:"model"`
+	Input dashscopeCloneInput `json:"input"`
+}
+
+// dashscopeCloneInput carries the create_voice action parameters.
+type dashscopeCloneInput struct {
+	Action      string `json:"action"`
+	TargetModel string `json:"target_model"`
+	Prefix      string `json:"prefix"`
+	URL         string `json:"url"`
+}
+
+// dashscopeCloneResponse is the voice-enrollment response envelope. A top-level
+// message marks a model-level error surfaced even on an HTTP 200.
+type dashscopeCloneResponse struct {
+	Output struct {
+		VoiceID string `json:"voice_id"`
+	} `json:"output"`
+	Message string `json:"message"`
 }