Struct TtsModelExecutor 

pub struct TtsModelExecutor { /* private fields */ }

Qwen3-TTS executor: text-to-speech synthesis.

Implementations

impl TtsModelExecutor

pub fn from_path( model_path: &str, device: CandleDevice, dtype: DType, ) -> Result<Self>

Load from model directory containing:

• config.json (TalkerConfig)
• model.safetensors (Talker weights)
• speech_tokenizer/model.safetensors (Vocoder weights)
• tokenizer_config.json + vocab.json + merges.txt (text tokenizer)

pub fn synthesize(&mut self, text: &str, language: &str) -> Result<Vec<f32>>

Synthesize speech from text.

Returns PCM samples at 24kHz as Vec.

Prompt structure (matches Python/qwen3-tts-rs): Prefill: [role_prefix(3)] + [tts_text_prefix(6) + codec_prefix(6)] + [first_text + codec_bos] Trailing: text_projection(remaining_text + tts_eos) — added per decode step

pub fn synthesize_streaming<F: FnMut(usize, &[f32])>( &mut self, text: &str, language: &str, chunk_frames: usize, on_chunk: F, ) -> Result<Vec<Vec<f32>>>

Streaming TTS: calls on_chunk with each audio chunk as soon as it’s ready.

Each chunk is chunk_frames codec frames decoded to audio (~800ms at default 10 frames). First chunk arrives after chunk_frames decode steps (~2-3s for 0.6B).

pub fn sample_rate(&self) -> usize

Get the output sample rate.

pub fn config(&self) -> &TalkerConfig

pub fn synthesize_voice_clone( &mut self, text: &str, language: &str, ref_audio_path: &str, ref_text: &str, ) -> Result<Vec<f32>>

Synthesize speech with voice cloning from a reference audio.

Uses ICL (in-context learning) prompting: the reference audio is encoded to codec tokens and prepended to the generation prompt, along with a speaker embedding extracted via ECAPA-TDNN.

Returns PCM samples at 24kHz as Vec.

Trait Implementations

impl ModelExecutor for TtsModelExecutor

fn info(&self) -> &ModelInfo

Get model information and metadata

fn prefill<'life0, 'life1, 'async_trait>( &'life0 self, _input: &'life1 PrefillInput, ) -> Pin<Box<dyn Future<Output = Result<PrefillOutput>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute prefill phase (process initial prompt)

fn decode<'life0, 'life1, 'async_trait>( &'life0 self, _input: &'life1 DecodeInput, ) -> Pin<Box<dyn Future<Output = Result<DecodeOutput>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute decode phase (generate next token)

fn capabilities(&self) -> ExecutorCapabilities

Get executor capabilities

fn release_cache(&self, _: &str)

Release KV cache and state for a completed sequence.

fn status(&self) -> ExecutorStatus

Get current executor status

fn batch_decode<'life0, 'life1, 'async_trait>( &'life0 self, inputs: &'life1 [DecodeInput], ) -> Pin<Box<dyn Future<Output = Result<Vec<DecodeOutput>, FerrumError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Batch decode: process multiple sequences in one forward pass.

fn forward<'life0, 'life1, 'async_trait>( &'life0 self, _input: &'life1 Arc<dyn TensorLike>, ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn TensorLike>, FerrumError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Optional: full forward pass (for non-autoregressive use cases)

fn truncate_kv<'life0, 'life1, 'async_trait>( &'life0 self, _kv_cache: &'life1 Arc<dyn KvCacheHandle>, _new_len: usize, ) -> Pin<Box<dyn Future<Output = Result<(), FerrumError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Roll the KV cache for this executor’s sequence back to new_len. Used by speculative decoding on partial rejection so the next iteration sees a KV prefix that matches the accepted token stream. Default: Ok(()) — executors that don’t cache per-sequence state (stub, mock) are inherently tolerant; real LLM executors override.

fn forward_verify<'life0, 'life1, 'async_trait>( &'life0 self, inputs: &'life1 [DecodeInput], ) -> Pin<Box<dyn Future<Output = Result<Vec<DecodeOutput>, FerrumError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Multi-position decode-verify: one forward over N+1 tokens, producing one logits row per position. Used by speculative decoding’s target path so we don’t pay N+1 sequential forwards.

fn warmup<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<(), FerrumError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Warm up executor (load model, allocate memory, etc.)

fn shutdown<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<(), FerrumError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Shutdown executor gracefully