964 lines
41 KiB
JavaScript
964 lines
41 KiB
JavaScript
import { getPreviewString, initVoiceMap, saveTtsProviderSettings } from './index.js';
|
|
import { event_types, eventSource, getRequestHeaders } from '../../../script.js';
|
|
import { SECRET_KEYS, secret_state } from '../../secrets.js';
|
|
import { getBase64Async } from '../../utils.js';
|
|
|
|
export { MiniMaxTtsProvider };
|
|
|
|
class MiniMaxTtsProvider {
|
|
//########//
|
|
// Config //
|
|
//########//
|
|
|
|
settings;
|
|
voices = [];
|
|
separator = ' . ';
|
|
audioElement = document.createElement('audio');
|
|
|
|
defaultSettings = {
|
|
apiHost: 'https://api.minimax.io',
|
|
model: 'speech-02-hd',
|
|
voiceMap: {},
|
|
speed: { default: 1.0, min: 0.5, max: 2.0, step: 0.1 },
|
|
volume: { default: 1.0, min: 0.0, max: 10.0, step: 0.1 },
|
|
pitch: { default: 0, min: -12, max: 12, step: 1 },
|
|
audioSampleRate: 32000,
|
|
bitrate: 128000,
|
|
format: 'mp3',
|
|
customModels: [],
|
|
customVoices: [],
|
|
customVoiceId: '',
|
|
};
|
|
|
|
// MiniMax API doesn't provide a method to list user's cloned voices
|
|
// so users need to manually input their custom cloned voice IDs
|
|
static defaultVoices = [
|
|
{ name: 'Unrestrained Young Man', voice_id: 'Chinese (Mandarin)_Unrestrained_Young_Man', lang: 'zh-CN', preview_url: null },
|
|
];
|
|
|
|
// default models (by MiniMax doc)
|
|
static defaultModels = [
|
|
{ id: 'speech-02-hd', name: 'Speech-02-HD (High Quality)' },
|
|
{ id: 'speech-02-turbo', name: 'Speech-02-Turbo (Fast)' },
|
|
{ id: 'speech-01', name: 'Speech-01 (Legacy)' },
|
|
{ id: 'speech-01-240228', name: 'Speech-01-240228 (Legacy)' },
|
|
];
|
|
|
|
availableModels = [];
|
|
availableVoices = [];
|
|
|
|
get settingsHtml() {
|
|
return `
|
|
<div class="minimax_tts_settings">
|
|
<div class="tts_block justifyCenter">
|
|
<div id="api_key_minimax" class="menu_button menu_button_icon manage-api-keys" data-key="api_key_minimax">
|
|
<i class="fa-solid fa-key"></i>
|
|
<span>Click to set API Key</span>
|
|
</div>
|
|
<div id="minimax_group_id" class="menu_button menu_button_icon manage-api-keys" data-key="minimax_group_id">
|
|
<i class="fa-solid fa-key"></i>
|
|
<span>Click to set Group ID</span>
|
|
</div>
|
|
</div>
|
|
<div class="tts_block">
|
|
<label for="minimax_tts_api_host">API Host</label>
|
|
<select id="minimax_tts_api_host" class="text_pole">
|
|
<option value="https://api.minimax.io">Official (api.minimax.io)</option>
|
|
<option value="https://api.minimaxi.chat">Global (api.minimaxi.chat)</option>
|
|
<option value="https://api.minimax.chat">Mainland China (api.minimax.chat)</option>
|
|
</select>
|
|
</div>
|
|
<div class="tts_block">
|
|
<label for="minimax_tts_model">Model</label>
|
|
<select id="minimax_tts_model" class="text_pole">
|
|
<option value="speech-02-hd">Speech-02-HD (High Quality)</option>
|
|
<option value="speech-02-turbo">Speech-02-Turbo (Fast)</option>
|
|
<option value="speech-01">Speech-01 (Legacy)</option>
|
|
<option value="speech-01-240228">Speech-01-240228 (Legacy)</option>
|
|
</select>
|
|
</div>
|
|
<div class="tts_block">
|
|
<input id="minimax_connect" class="menu_button" type="button" value="Connect" />
|
|
<input id="minimax_refresh" class="menu_button" type="button" value="Refresh" />
|
|
</div>
|
|
|
|
<div class="tts_block">
|
|
<label for="minimax_tts_speed">Speed: <span id="minimax_tts_speed_output"></span></label>
|
|
<input id="minimax_tts_speed" type="range" value="${this.defaultSettings.speed.default}" min="${this.defaultSettings.speed.min}" max="${this.defaultSettings.speed.max}" step="${this.defaultSettings.speed.step}" />
|
|
</div>
|
|
<div class="tts_block">
|
|
<label for="minimax_tts_volume">Volume: <span id="minimax_tts_volume_output"></span></label>
|
|
<input id="minimax_tts_volume" type="range" value="${this.defaultSettings.volume.default}" min="${this.defaultSettings.volume.min}" max="${this.defaultSettings.volume.max}" step="${this.defaultSettings.volume.step}" />
|
|
</div>
|
|
<div class="tts_block">
|
|
<label for="minimax_tts_pitch">Pitch: <span id="minimax_tts_pitch_output"></span></label>
|
|
<input id="minimax_tts_pitch" type="range" value="${this.defaultSettings.pitch.default}" min="${this.defaultSettings.pitch.min}" max="${this.defaultSettings.pitch.max}" step="${this.defaultSettings.pitch.step}" />
|
|
</div>
|
|
<div class="tts_block">
|
|
<label for="minimax_tts_format">Audio Format</label>
|
|
<select id="minimax_tts_format" class="text_pole">
|
|
<option value="mp3">MP3</option>
|
|
<option value="wav">WAV</option>
|
|
<option value="flac">FLAC</option>
|
|
</select>
|
|
</div>
|
|
|
|
<hr>
|
|
<div class="tts_block">
|
|
<label for="minimax_tts_custom_voice_id">Custom Voice ID (for 'customVoice' option)</label>
|
|
<input id="minimax_tts_custom_voice_id" type="text" class="text_pole" placeholder="Enter custom voice ID from MiniMax platform"/>
|
|
</div>
|
|
|
|
<hr>
|
|
<div id="minimax_custom_voice_cloning" class="tts_block flexFlowColumn">
|
|
<h4>Custom Voice Management</h4>
|
|
<div class="tts_block wide100p">
|
|
<input id="minimax_custom_voice_name" type="text" class="text_pole" placeholder="Voice Name"/>
|
|
</div>
|
|
<div class="tts_block wide100p">
|
|
<input id="minimax_custom_voice_id" type="text" class="text_pole" placeholder="Voice ID (from MiniMax platform)"/>
|
|
</div>
|
|
<div class="tts_block wide100p">
|
|
<select id="minimax_custom_voice_lang" class="text_pole">
|
|
<option value="auto">Auto Detect</option>
|
|
<option value="Chinese">Chinese (中文)</option>
|
|
<option value="Chinese,Yue">Chinese, Yue (粤语)</option>
|
|
<option value="English">English</option>
|
|
<option value="Arabic">Arabic (العربية)</option>
|
|
<option value="Russian">Russian (Русский)</option>
|
|
<option value="Spanish">Spanish (Español)</option>
|
|
<option value="French">French (Français)</option>
|
|
<option value="Portuguese">Portuguese (Português)</option>
|
|
<option value="German">German (Deutsch)</option>
|
|
<option value="Turkish">Turkish (Türkçe)</option>
|
|
<option value="Dutch">Dutch (Nederlands)</option>
|
|
<option value="Ukrainian">Ukrainian (Українська)</option>
|
|
<option value="Vietnamese">Vietnamese (Tiếng Việt)</option>
|
|
<option value="Indonesian">Indonesian (Bahasa Indonesia)</option>
|
|
<option value="Japanese">Japanese (日本語)</option>
|
|
<option value="Italian">Italian (Italiano)</option>
|
|
<option value="Korean">Korean (한국어)</option>
|
|
<option value="Thai">Thai (ไทย)</option>
|
|
<option value="Polish">Polish (Polski)</option>
|
|
<option value="Romanian">Romanian (Română)</option>
|
|
<option value="Greek">Greek (Ελληνικά)</option>
|
|
<option value="Czech">Czech (Čeština)</option>
|
|
<option value="Finnish">Finnish (Suomi)</option>
|
|
<option value="Hindi">Hindi (हिन्दी)</option>
|
|
</select>
|
|
</div>
|
|
<div class="tts_block">
|
|
<input id="minimax_add_custom_voice" class="menu_button" type="button" value="Add Custom Voice">
|
|
</div>
|
|
<div id="minimax_custom_voices_list" style="margin-top: 10px;"></div>
|
|
</div>
|
|
|
|
<hr>
|
|
<div id="minimax_custom_model_management" class="tts_block flexFlowColumn">
|
|
<h4>Custom Model Management</h4>
|
|
<div class="tts_block wide100p">
|
|
<input id="minimax_custom_model_id" type="text" class="text_pole" placeholder="Model ID"/>
|
|
</div>
|
|
<div class="tts_block wide100p">
|
|
<input id="minimax_custom_model_name" type="text" class="text_pole" placeholder="Model Name"/>
|
|
</div>
|
|
<div class="tts_block">
|
|
<input id="minimax_add_custom_model" class="menu_button" type="button" value="Add Custom Model">
|
|
</div>
|
|
<div id="minimax_custom_models_list" style="margin-top: 10px;"></div>
|
|
</div>
|
|
</div>
|
|
`;
|
|
}
|
|
|
|
constructor() {
|
|
this.handler = async function (/** @type {string} */ key) {
|
|
if (![SECRET_KEYS.MINIMAX, SECRET_KEYS.MINIMAX_GROUP_ID].includes(key)) return;
|
|
$('#api_key_minimax').toggleClass('success', !!secret_state[SECRET_KEYS.MINIMAX]);
|
|
$('#minimax_group_id').toggleClass('success', !!secret_state[SECRET_KEYS.MINIMAX_GROUP_ID]);
|
|
await this.onRefreshClick();
|
|
}.bind(this);
|
|
}
|
|
|
|
dispose() {
|
|
[event_types.SECRET_WRITTEN, event_types.SECRET_DELETED, event_types.SECRET_ROTATED].forEach(event => {
|
|
eventSource.removeListener(event, this.handler);
|
|
});
|
|
}
|
|
|
|
onSettingsChange() {
|
|
this.settings.apiHost = $('#minimax_tts_api_host').val();
|
|
this.settings.speed = parseFloat($('#minimax_tts_speed').val().toString());
|
|
this.settings.volume = parseFloat($('#minimax_tts_volume').val().toString());
|
|
this.settings.pitch = parseInt($('#minimax_tts_pitch').val().toString());
|
|
this.settings.model = $('#minimax_tts_model').find(':selected').val();
|
|
this.settings.format = $('#minimax_tts_format').find(':selected').val();
|
|
this.settings.customVoiceId = $('#minimax_tts_custom_voice_id').val();
|
|
|
|
$('#minimax_tts_speed_output').text(this.settings.speed.toFixed(1));
|
|
$('#minimax_tts_volume_output').text(this.settings.volume.toFixed(1));
|
|
$('#minimax_tts_pitch_output').text(this.settings.pitch);
|
|
|
|
saveTtsProviderSettings();
|
|
}
|
|
|
|
addCustomModel() {
|
|
const modelId = $('#minimax_custom_model_id').val().toString().trim();
|
|
const modelName = $('#minimax_custom_model_name').val().toString().trim();
|
|
|
|
if (!modelId || !modelName) {
|
|
toastr.error('Please enter model ID and name');
|
|
return;
|
|
}
|
|
|
|
// Check if already exists in custom models
|
|
if (this.settings.customModels.find(m => m.id === modelId)) {
|
|
toastr.error('Model ID already exists in custom models');
|
|
return;
|
|
}
|
|
|
|
// Check if conflicts with default models
|
|
if (MiniMaxTtsProvider.defaultModels.find(m => m.id === modelId)) {
|
|
toastr.error('Model ID conflicts with default model. Please use a different model ID.');
|
|
return;
|
|
}
|
|
|
|
// Check if conflicts with default model names
|
|
if (MiniMaxTtsProvider.defaultModels.find(m => m.name === modelName)) {
|
|
toastr.error('Model name conflicts with default model. Please use a different model name.');
|
|
return;
|
|
}
|
|
|
|
this.settings.customModels.push({ id: modelId, name: modelName });
|
|
$('#minimax_custom_model_id').val('');
|
|
$('#minimax_custom_model_name').val('');
|
|
|
|
this.updateCustomModelsDisplay();
|
|
this.updateModelSelect(this.getAllModels());
|
|
saveTtsProviderSettings();
|
|
toastr.success('Model added successfully');
|
|
}
|
|
|
|
removeCustomModel(modelId) {
|
|
this.settings.customModels = this.settings.customModels.filter(m => m.id !== modelId);
|
|
this.updateCustomModelsDisplay();
|
|
this.updateModelSelect(this.getAllModels());
|
|
saveTtsProviderSettings();
|
|
|
|
toastr.success('Model removed successfully');
|
|
}
|
|
|
|
addCustomVoice() {
|
|
const voiceName = $('#minimax_custom_voice_name').val().toString().trim();
|
|
const voiceId = $('#minimax_custom_voice_id').val().toString().trim();
|
|
const voiceLang = $('#minimax_custom_voice_lang').val().toString().trim();
|
|
|
|
if (!voiceName || !voiceId) {
|
|
toastr.error('Please enter voice name and ID');
|
|
return;
|
|
}
|
|
|
|
// Check if already exists in custom voices
|
|
if (this.settings.customVoices.find(v => v.voice_id === voiceId)) {
|
|
toastr.error('Voice ID already exists in custom voices');
|
|
return;
|
|
}
|
|
|
|
// Check if conflicts with default voices
|
|
if (MiniMaxTtsProvider.defaultVoices.find(v => v.voice_id === voiceId)) {
|
|
toastr.error('Voice ID conflicts with default voice. Please use a different voice ID.');
|
|
return;
|
|
}
|
|
|
|
// Check if conflicts with default voice names
|
|
if (MiniMaxTtsProvider.defaultVoices.find(v => v.name === voiceName)) {
|
|
toastr.error('Voice name conflicts with default voice. Please use a different voice name.');
|
|
return;
|
|
}
|
|
|
|
// Convert display name to standard language code before saving
|
|
const standardLangCode = this.convertDisplayNameToLanguageCode(voiceLang);
|
|
|
|
this.settings.customVoices.push({
|
|
name: voiceName,
|
|
voice_id: voiceId,
|
|
lang: standardLangCode,
|
|
preview_url: null,
|
|
});
|
|
|
|
$('#minimax_custom_voice_name').val('');
|
|
$('#minimax_custom_voice_id').val('');
|
|
$('#minimax_custom_voice_lang').val('auto');
|
|
|
|
this.updateCustomVoicesDisplay();
|
|
initVoiceMap(); // Update TTS extension voiceMap
|
|
saveTtsProviderSettings();
|
|
toastr.success('Voice added successfully');
|
|
}
|
|
|
|
// Remove custom voice
|
|
removeCustomVoice(voiceId) {
|
|
this.settings.customVoices = this.settings.customVoices.filter(v => v.voice_id !== voiceId);
|
|
this.updateCustomVoicesDisplay();
|
|
initVoiceMap(); // Update TTS extension voiceMap
|
|
saveTtsProviderSettings();
|
|
toastr.success('Voice removed successfully');
|
|
}
|
|
|
|
// Helper function to escape HTML
|
|
escapeHtml(text) {
|
|
const div = document.createElement('div');
|
|
div.textContent = text;
|
|
return div.innerHTML;
|
|
}
|
|
|
|
// Update custom models display
|
|
updateCustomModelsDisplay() {
|
|
const container = $('#minimax_custom_models_list');
|
|
container.empty();
|
|
|
|
if (this.settings.customModels.length === 0) {
|
|
container.append('<div class="minimax-empty-list">No custom models added</div>');
|
|
return;
|
|
}
|
|
|
|
this.settings.customModels.forEach(model => {
|
|
const modelDiv = $('<div></div>').addClass('minimax-custom-item');
|
|
|
|
const modelInfo = $('<div></div>').addClass('minimax-custom-item-info');
|
|
const modelName = $('<div></div>').addClass('minimax-custom-item-name').text(model.name);
|
|
const modelId = $('<div></div>').addClass('minimax-custom-item-details').text(`(${model.id})`);
|
|
modelInfo.append(modelName).append(modelId);
|
|
|
|
const removeBtn = $('<button></button>')
|
|
.addClass('menu_button minimax-custom-item-remove')
|
|
.text('Remove')
|
|
.on('click', () => {
|
|
try {
|
|
this.removeCustomModel(model.id);
|
|
} catch (error) {
|
|
console.error('MiniMax TTS: Error removing custom model:', error);
|
|
toastr.error(`Failed to remove custom model: ${error.message}`);
|
|
}
|
|
});
|
|
|
|
modelDiv.append(modelInfo).append(removeBtn);
|
|
container.append(modelDiv);
|
|
});
|
|
}
|
|
|
|
// Update custom voices display
|
|
updateCustomVoicesDisplay() {
|
|
const container = $('#minimax_custom_voices_list');
|
|
container.empty();
|
|
|
|
if (this.settings.customVoices.length === 0) {
|
|
container.append('<div class="minimax-empty-list">No custom voices added</div>');
|
|
return;
|
|
}
|
|
|
|
this.settings.customVoices.forEach(voice => {
|
|
const voiceDiv = $('<div></div>').addClass('minimax-custom-item');
|
|
|
|
const voiceInfo = $('<div></div>').addClass('minimax-custom-item-info');
|
|
const voiceName = $('<div></div>').addClass('minimax-custom-item-name').text(voice.name);
|
|
const voiceDetails = $('<div></div>').addClass('minimax-custom-item-details').text(`(${voice.voice_id}) - ${voice.lang}`);
|
|
voiceInfo.append(voiceName).append(voiceDetails);
|
|
|
|
const removeBtn = $('<button></button>')
|
|
.addClass('menu_button minimax-custom-item-remove')
|
|
.text('Remove')
|
|
.on('click', () => {
|
|
try {
|
|
this.removeCustomVoice(voice.voice_id);
|
|
} catch (error) {
|
|
console.error('MiniMax TTS: Error removing custom voice:', error);
|
|
toastr.error(`Failed to remove custom voice: ${error.message}`);
|
|
}
|
|
});
|
|
|
|
voiceDiv.append(voiceInfo).append(removeBtn);
|
|
container.append(voiceDiv);
|
|
});
|
|
}
|
|
|
|
// Get all models (default + custom)
|
|
getAllModels() {
|
|
return [...MiniMaxTtsProvider.defaultModels, ...this.settings.customModels];
|
|
}
|
|
|
|
// Get all voices (default + custom)
|
|
getAllVoices() {
|
|
return [...MiniMaxTtsProvider.defaultVoices, ...this.settings.customVoices];
|
|
}
|
|
|
|
/**
|
|
* Convert display names to standard language codes
|
|
* @param {string} displayName Language display name
|
|
* @returns {string} Standard language code
|
|
*/
|
|
convertDisplayNameToLanguageCode(displayName) {
|
|
const displayNameToCode = {
|
|
'Chinese': 'zh-CN',
|
|
'Chinese,Yue': 'zh-TW',
|
|
'English': 'en-US',
|
|
'Japanese': 'ja-JP',
|
|
'Korean': 'ko-KR',
|
|
'French': 'fr-FR',
|
|
'German': 'de-DE',
|
|
'Spanish': 'es-ES',
|
|
'Portuguese': 'pt-BR',
|
|
'Italian': 'it-IT',
|
|
'Arabic': 'ar-SA',
|
|
'Russian': 'ru-RU',
|
|
'Turkish': 'tr-TR',
|
|
'Dutch': 'nl-NL',
|
|
'Ukrainian': 'uk-UA',
|
|
'Vietnamese': 'vi-VN',
|
|
'Indonesian': 'id-ID',
|
|
'Thai': 'th-TH',
|
|
'Polish': 'pl-PL',
|
|
'Romanian': 'ro-RO',
|
|
'Greek': 'el-GR',
|
|
'Czech': 'cs-CZ',
|
|
'Finnish': 'fi-FI',
|
|
'Hindi': 'hi-IN',
|
|
};
|
|
|
|
return displayNameToCode[displayName] || displayName;
|
|
}
|
|
|
|
updateModelSelect(models) {
|
|
const modelSelect = $('#minimax_tts_model');
|
|
const currentValue = modelSelect.val();
|
|
|
|
// Clear existing options
|
|
modelSelect.empty();
|
|
|
|
// Add all models
|
|
models.forEach(model => {
|
|
const option = $('<option></option>');
|
|
option.val(model.id);
|
|
option.text(model.name);
|
|
modelSelect.append(option);
|
|
});
|
|
|
|
// Restore previous selection if it still exists
|
|
if (currentValue && models.find(m => m.id === currentValue)) {
|
|
modelSelect.val(currentValue);
|
|
}
|
|
}
|
|
|
|
async loadSettings(settings) {
|
|
// Populate Provider UI given input settings
|
|
if (Object.keys(settings).length === 0) {
|
|
console.info('Using default MiniMax TTS Provider settings');
|
|
}
|
|
|
|
// Only accept keys defined in defaultSettings
|
|
this.settings = { ...this.defaultSettings };
|
|
|
|
// Flatten the settings fields with default/min/max definitions so the actual values are used
|
|
this.settings = Object.fromEntries(
|
|
Object.entries(this.defaultSettings).map(([key, value]) => {
|
|
if (value && typeof value === 'object' && 'default' in value) {
|
|
return [key, value.default];
|
|
}
|
|
return [key, value];
|
|
}),
|
|
);
|
|
|
|
for (const key in settings) {
|
|
if (key in this.settings) {
|
|
this.settings[key] = settings[key];
|
|
} else {
|
|
console.warn(`Invalid setting passed to MiniMax TTS Provider: ${key}`);
|
|
}
|
|
}
|
|
|
|
// Ensure custom configuration arrays exist
|
|
if (!this.settings.customModels) this.settings.customModels = [];
|
|
if (!this.settings.customVoices) this.settings.customVoices = [];
|
|
|
|
// # Migrate settings
|
|
// Pitch value changed from float to int. If it's a float, let's try to extrapolate it to the new range
|
|
if (!Number.isInteger(this.settings.pitch)) {
|
|
const oldPitch = parseFloat(this.settings.pitch);
|
|
if (!isNaN(oldPitch)) {
|
|
// map old [0.5..1.0] to [-12..0], and [1.0..2.0] to [0..12] (old default was 1.0, new default is 0)
|
|
const newPitch = (oldPitch < 1.0) ? (oldPitch - 1.0) * 24 : (oldPitch - 1.0) * 12;
|
|
this.settings.pitch = Math.max(-12, Math.min(12, Math.round(newPitch)));
|
|
console.info(`MiniMax TTS: Migrated pitch from ${oldPitch} to ${this.settings.pitch}`);
|
|
} else {
|
|
this.settings.pitch = 0;
|
|
console.info(`MiniMax TTS: Migration reset pitch to default ${this.settings.pitch}`);
|
|
}
|
|
}
|
|
|
|
$('#minimax_tts_api_host').val(this.settings.apiHost || 'https://api.minimax.io');
|
|
$('#minimax_tts_model').val(this.settings.model);
|
|
$('#minimax_tts_speed').val(this.settings.speed);
|
|
$('#minimax_tts_volume').val(this.settings.volume);
|
|
$('#minimax_tts_pitch').val(this.settings.pitch);
|
|
$('#minimax_tts_format').val(this.settings.format);
|
|
$('#minimax_tts_custom_voice_id').val(this.settings.customVoiceId);
|
|
|
|
$('#minimax_connect').on('click', () => {
|
|
try {
|
|
this.onConnectClick();
|
|
} catch (error) {
|
|
console.error('MiniMax TTS: Error in connect click handler:', error);
|
|
toastr.error(`Connection failed: ${error.message}`);
|
|
}
|
|
});
|
|
$('#minimax_refresh').on('click', () => {
|
|
try {
|
|
this.onRefreshClick();
|
|
} catch (error) {
|
|
console.error('MiniMax TTS: Error in refresh click handler:', error);
|
|
toastr.error(`Refresh failed: ${error.message}`);
|
|
}
|
|
});
|
|
$('#minimax_tts_api_host').on('change', this.onSettingsChange.bind(this));
|
|
$('#minimax_tts_speed').on('input', this.onSettingsChange.bind(this));
|
|
$('#minimax_tts_volume').on('input', this.onSettingsChange.bind(this));
|
|
$('#minimax_tts_pitch').on('input', this.onSettingsChange.bind(this));
|
|
$('#minimax_tts_model').on('change', this.onSettingsChange.bind(this));
|
|
$('#minimax_tts_format').on('change', this.onSettingsChange.bind(this));
|
|
$('#minimax_tts_custom_voice_id').on('input', this.onSettingsChange.bind(this));
|
|
|
|
// Custom model and voice event listeners
|
|
$('#minimax_add_custom_model').on('click', () => {
|
|
try {
|
|
this.addCustomModel();
|
|
} catch (error) {
|
|
console.error('MiniMax TTS: Error adding custom model:', error);
|
|
toastr.error(`Failed to add custom model: ${error.message}`);
|
|
}
|
|
});
|
|
$('#minimax_add_custom_voice').on('click', () => {
|
|
try {
|
|
this.addCustomVoice();
|
|
} catch (error) {
|
|
console.error('MiniMax TTS: Error adding custom voice:', error);
|
|
toastr.error(`Failed to add custom voice: ${error.message}`);
|
|
}
|
|
});
|
|
|
|
// Keyboard event listeners
|
|
const ENTER_KEY = 13;
|
|
$('#minimax_custom_model_id, #minimax_custom_model_name').on('keypress', (e) => {
|
|
if (e.which === ENTER_KEY) {
|
|
try {
|
|
this.addCustomModel();
|
|
} catch (error) {
|
|
console.error('MiniMax TTS: Error adding custom model via keyboard:', error);
|
|
toastr.error(`Failed to add custom model: ${error.message}`);
|
|
}
|
|
}
|
|
});
|
|
|
|
$('#minimax_custom_voice_name, #minimax_custom_voice_id').on('keypress', (e) => {
|
|
if (e.which === ENTER_KEY) {
|
|
try {
|
|
this.addCustomVoice();
|
|
} catch (error) {
|
|
console.error('MiniMax TTS: Error adding custom voice via keyboard:', error);
|
|
toastr.error(`Failed to add custom voice: ${error.message}`);
|
|
}
|
|
}
|
|
});
|
|
|
|
$('#minimax_tts_speed_output').text(this.settings.speed.toFixed(1));
|
|
$('#minimax_tts_volume_output').text(this.settings.volume.toFixed(1));
|
|
$('#minimax_tts_pitch_output').text(this.settings.pitch);
|
|
|
|
// Initialize custom configuration display
|
|
this.updateCustomModelsDisplay();
|
|
this.updateCustomVoicesDisplay();
|
|
|
|
// Update model selector to include custom models
|
|
this.updateModelSelect(this.getAllModels());
|
|
|
|
// Initialize voice map for character voice assignment
|
|
try {
|
|
await initVoiceMap();
|
|
} catch (error) {
|
|
console.debug('MiniMax: Voice map initialization failed, but continuing');
|
|
}
|
|
|
|
$('#api_key_minimax').toggleClass('success', !!secret_state[SECRET_KEYS.MINIMAX]);
|
|
$('#minimax_group_id').toggleClass('success', !!secret_state[SECRET_KEYS.MINIMAX_GROUP_ID]);
|
|
[event_types.SECRET_WRITTEN, event_types.SECRET_DELETED, event_types.SECRET_ROTATED].forEach(event => {
|
|
eventSource.on(event, this.handler);
|
|
});
|
|
|
|
// Only check ready status when API credentials are available
|
|
if (secret_state[SECRET_KEYS.MINIMAX] && secret_state[SECRET_KEYS.MINIMAX_GROUP_ID]) {
|
|
try {
|
|
await this.checkReady();
|
|
console.debug('MiniMax TTS: Settings loaded and ready');
|
|
} catch (error) {
|
|
console.debug('MiniMax TTS: Settings loaded, but not ready:', error);
|
|
}
|
|
} else {
|
|
console.debug('MiniMax TTS: Settings loaded, waiting for API credentials');
|
|
}
|
|
}
|
|
|
|
// Perform a simple readiness check
|
|
async checkReady() {
|
|
if (!secret_state[SECRET_KEYS.MINIMAX] || !secret_state[SECRET_KEYS.MINIMAX_GROUP_ID]) {
|
|
const error = new Error('API Key and Group ID are required');
|
|
console.error('MiniMax TTS checkReady error:', error.message);
|
|
throw error;
|
|
}
|
|
// Try to fetch available models and voices, but don't block connection on failure
|
|
try {
|
|
await this.updateModelsAndVoices();
|
|
} catch (error) {
|
|
console.warn('MiniMax TTS: Failed to fetch models/voices during ready check, will use all available:', error);
|
|
// Even if API call fails, set all available values to ensure basic functionality
|
|
this.availableModels = this.getAllModels();
|
|
this.availableVoices = this.getAllVoices();
|
|
}
|
|
|
|
// Ensure at least voices are available
|
|
if (!this.availableVoices || this.availableVoices.length === 0) {
|
|
this.availableVoices = this.getAllVoices();
|
|
}
|
|
}
|
|
|
|
async onRefreshClick() {
|
|
try {
|
|
await this.updateModelsAndVoices();
|
|
await initVoiceMap(); // Update voice map after refresh
|
|
toastr.success('MiniMax TTS: Models and voices refreshed successfully');
|
|
} catch (error) {
|
|
toastr.error(`MiniMax TTS: Failed to refresh - ${error.message}`);
|
|
}
|
|
}
|
|
|
|
async onConnectClick() {
|
|
try {
|
|
await this.checkReady();
|
|
await initVoiceMap(); // Update voice map after connection
|
|
toastr.success('MiniMax TTS: Connected successfully');
|
|
saveTtsProviderSettings();
|
|
} catch (error) {
|
|
toastr.error(`MiniMax TTS: ${error.message}`);
|
|
}
|
|
}
|
|
|
|
async getVoice(voiceName) {
|
|
if (!voiceName) {
|
|
const error = new Error('TTS Voice name not provided');
|
|
console.error('MiniMax TTS getVoice error:', error.message);
|
|
throw error;
|
|
}
|
|
|
|
// If no available voices, try to fetch them
|
|
if (!this.availableVoices || this.availableVoices.length === 0) {
|
|
this.availableVoices = await this.fetchTtsVoiceObjects();
|
|
}
|
|
|
|
// Ensure at least voices are available
|
|
if (!this.availableVoices || this.availableVoices.length === 0) {
|
|
this.availableVoices = this.getAllVoices();
|
|
}
|
|
|
|
const voice = this.availableVoices.find(voice =>
|
|
voice.voice_id === voiceName || voice.name === voiceName,
|
|
);
|
|
|
|
if (!voice) {
|
|
const error = new Error(`TTS Voice not found: ${voiceName}`);
|
|
console.error('MiniMax TTS getVoice error:', error.message);
|
|
throw error;
|
|
}
|
|
|
|
return voice;
|
|
}
|
|
|
|
async generateTts(text, voiceId) {
|
|
// If voiceId is 'customVoice', use the custom voice ID from settings
|
|
if (voiceId === 'customVoice') {
|
|
const customVoiceId = this.settings.customVoiceId;
|
|
if (!customVoiceId || customVoiceId.trim() === '') {
|
|
const error = new Error('Please enter custom voice ID in settings first');
|
|
console.error('MiniMax TTS generateTts error:', error.message);
|
|
throw error;
|
|
}
|
|
voiceId = customVoiceId.trim();
|
|
}
|
|
|
|
// Get the voice object to determine language
|
|
let language = null;
|
|
try {
|
|
const voice = await this.getVoice(voiceId);
|
|
if (voice && voice.lang) {
|
|
language = this.mapLanguageToMiniMaxFormat(voice.lang);
|
|
console.debug(`MiniMax TTS: Using voice language ${voice.lang}, API language: ${language}`);
|
|
}
|
|
} catch (error) {
|
|
console.debug('MiniMax TTS: Could not determine voice language, using default');
|
|
}
|
|
|
|
return await this.fetchTtsGeneration(text, voiceId, language);
|
|
}
|
|
|
|
async fetchTtsVoiceObjects() {
|
|
try {
|
|
if (!secret_state[SECRET_KEYS.MINIMAX] || !secret_state[SECRET_KEYS.MINIMAX_GROUP_ID]) {
|
|
console.warn('MiniMax TTS: API Key and Group ID required for fetching voices');
|
|
console.warn('Using all available voices (default + custom). Please check your API credentials');
|
|
return this.getAllVoices();
|
|
}
|
|
|
|
// MiniMax API doesn't provide a voices listing endpoint
|
|
// Using all available voices (default + custom)
|
|
console.info('MiniMax TTS: Using all available voices (default + custom)');
|
|
return this.getAllVoices();
|
|
} catch (error) {
|
|
console.error('Error fetching MiniMax voices:', error);
|
|
console.warn('Using all available voices (default + custom). Please check your API credentials');
|
|
return this.getAllVoices();
|
|
}
|
|
}
|
|
|
|
async fetchTtsModels() {
|
|
// MiniMax API doesn't provide a models listing endpoint
|
|
// Using all available models (default + custom)
|
|
console.info('MiniMax TTS: Using all available models (default + custom)');
|
|
this.availableModels = this.getAllModels();
|
|
return this.getAllModels();
|
|
}
|
|
|
|
async updateModelsAndVoices() {
|
|
try {
|
|
// Get models list
|
|
this.availableModels = await this.fetchTtsModels();
|
|
console.info(`MiniMax TTS: Loaded ${this.availableModels.length} models`);
|
|
|
|
// Get voices list (now fetched from API)
|
|
this.availableVoices = await this.fetchTtsVoiceObjects();
|
|
console.info(`MiniMax TTS: Loaded ${this.availableVoices.length} voices`);
|
|
|
|
// Update model dropdown
|
|
this.updateModelSelect(this.availableModels);
|
|
|
|
return {
|
|
models: this.availableModels,
|
|
voices: this.availableVoices,
|
|
};
|
|
} catch (error) {
|
|
console.error('MiniMax TTS: Failed to update models and voices:', error);
|
|
// Set all available values to ensure basic functionality
|
|
this.availableModels = this.getAllModels();
|
|
this.availableVoices = this.getAllVoices();
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
// Get correct MIME type
|
|
getAudioMimeType(format) {
|
|
const mimeTypes = {
|
|
'mp3': 'audio/mpeg',
|
|
'wav': 'audio/wav',
|
|
'pcm': 'audio/pcm',
|
|
'flac': 'audio/flac',
|
|
'aac': 'audio/aac',
|
|
};
|
|
return mimeTypes[format] || 'audio/mpeg';
|
|
}
|
|
|
|
async fetchTtsGeneration(inputText, voiceId, language = null) {
|
|
console.info(`Generating new MiniMax TTS for voice_id ${voiceId}`);
|
|
|
|
if (!secret_state[SECRET_KEYS.MINIMAX] || !secret_state[SECRET_KEYS.MINIMAX_GROUP_ID]) {
|
|
const error = new Error('API Key and Group ID are required');
|
|
console.error('MiniMax TTS fetchTtsGeneration error:', error.message);
|
|
throw error;
|
|
}
|
|
|
|
/** @param {number} number @param {number} lower @param {number} upper @returns {number} */
|
|
const clamp = (number, lower, upper) => Math.min(Math.max(number, lower), upper);
|
|
|
|
const requestBody = {
|
|
text: inputText,
|
|
voiceId: voiceId,
|
|
apiHost: this.settings.apiHost,
|
|
model: this.settings.model || this.defaultSettings.model,
|
|
speed: clamp(Number(this.settings.speed) || this.defaultSettings.speed.default, this.defaultSettings.speed.min, this.defaultSettings.speed.max),
|
|
volume: clamp(Number(this.settings.volume) || this.defaultSettings.volume.default, this.defaultSettings.volume.min, this.defaultSettings.volume.max),
|
|
pitch: clamp(Math.round(Number(this.settings.pitch)) || this.defaultSettings.pitch.default, this.defaultSettings.pitch.min, this.defaultSettings.pitch.max),
|
|
audioSampleRate: Number(this.settings.audioSampleRate) || this.defaultSettings.audioSampleRate,
|
|
bitrate: Number(this.settings.bitrate) || this.defaultSettings.bitrate,
|
|
format: this.settings.format || this.defaultSettings.format,
|
|
language: language,
|
|
};
|
|
|
|
console.debug('MiniMax TTS Request:', {
|
|
body: { ...requestBody, voiceId: '[REDACTED]' },
|
|
});
|
|
|
|
try {
|
|
const response = await fetch('/api/minimax/generate-voice', {
|
|
method: 'POST',
|
|
headers: getRequestHeaders(),
|
|
body: JSON.stringify(requestBody),
|
|
});
|
|
|
|
if (!response.ok) {
|
|
let errorMessage = `HTTP ${response.status}`;
|
|
|
|
try {
|
|
// Try to parse JSON error response from backend
|
|
const errorData = await response.json();
|
|
console.error('MiniMax TTS backend error:', errorData);
|
|
errorMessage = errorData.error || errorMessage;
|
|
} catch (jsonError) {
|
|
// If not JSON, try to read text
|
|
try {
|
|
const errorText = await response.text();
|
|
console.error('MiniMax TTS backend error (Text):', errorText);
|
|
errorMessage = errorText || errorMessage;
|
|
} catch (textError) {
|
|
console.error('MiniMax TTS: Failed to read error response:', textError);
|
|
}
|
|
}
|
|
|
|
toastr.error(`${errorMessage}`, 'MiniMax TTS Generation Failed');
|
|
const error = new Error(errorMessage);
|
|
console.error('MiniMax TTS fetchTtsGeneration error:', error.message);
|
|
throw error;
|
|
}
|
|
|
|
// Backend handles all the complex processing and returns audio data directly
|
|
console.debug('MiniMax TTS: Audio response received from backend');
|
|
return response;
|
|
|
|
} catch (error) {
|
|
console.error('Error in MiniMax TTS generation:', error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Map language codes to MiniMax API supported language format
|
|
* @param {string} lang Language code or display name
|
|
* @returns {string} MiniMax API language format
|
|
*/
|
|
mapLanguageToMiniMaxFormat(lang) {
|
|
// Convert display name to language code if needed
|
|
const languageCode = this.convertDisplayNameToLanguageCode(lang);
|
|
|
|
// Then map language codes to MiniMax API format
|
|
const languageMap = {
|
|
'zh-CN': 'zh_CN',
|
|
'zh-TW': 'zh_TW',
|
|
'en-US': 'en_US',
|
|
'en-GB': 'en_GB',
|
|
'en-AU': 'en_AU',
|
|
'en-IN': 'en_IN',
|
|
'ja-JP': 'ja_JP',
|
|
'ko-KR': 'ko_KR',
|
|
'fr-FR': 'fr_FR',
|
|
'de-DE': 'de_DE',
|
|
'es-ES': 'es_ES',
|
|
'pt-BR': 'pt_BR',
|
|
'it-IT': 'it_IT',
|
|
'ar-SA': 'ar_SA',
|
|
'ru-RU': 'ru_RU',
|
|
'tr-TR': 'tr_TR',
|
|
'nl-NL': 'nl_NL',
|
|
'uk-UA': 'uk_UA',
|
|
'vi-VN': 'vi_VN',
|
|
'id-ID': 'id_ID',
|
|
'th-TH': 'th_TH',
|
|
'pl-PL': 'pl_PL',
|
|
'ro-RO': 'ro_RO',
|
|
'el-GR': 'el_GR',
|
|
'cs-CZ': 'cs_CZ',
|
|
'fi-FI': 'fi_FI',
|
|
'hi-IN': 'hi_IN',
|
|
};
|
|
|
|
// Return mapped language or default to auto
|
|
return languageMap[languageCode] || 'auto';
|
|
}
|
|
|
|
/**
|
|
* Preview TTS for a given voice ID.
|
|
* @param {string} voiceId Voice ID
|
|
*/
|
|
async previewTtsVoice(voiceId) {
|
|
this.audioElement.pause();
|
|
this.audioElement.currentTime = 0;
|
|
|
|
try {
|
|
const voice = await this.getVoice(voiceId);
|
|
// Get preview text based on voice language, defaulting to en-US
|
|
const previewLang = voice.lang || 'en-US';
|
|
const text = getPreviewString(previewLang);
|
|
|
|
// Map the language to MiniMax API format for the request
|
|
const apiLang = this.mapLanguageToMiniMaxFormat(previewLang);
|
|
console.debug(`MiniMax TTS: Using preview language ${previewLang}, API language: ${apiLang}`);
|
|
|
|
const response = await this.fetchTtsGeneration(text, voiceId, apiLang);
|
|
|
|
if (!response.ok) {
|
|
const errorText = await response.text();
|
|
const error = new Error(`HTTP ${response.status}: ${errorText}`);
|
|
console.error('MiniMax TTS previewTtsVoice error:', error.message);
|
|
throw error;
|
|
}
|
|
|
|
const audio = await response.blob();
|
|
console.debug(`MiniMax TTS: Audio blob size: ${audio.size}, type: ${audio.type}`);
|
|
|
|
// Use the same method as other TTS providers - convert to base64 data URL
|
|
const srcUrl = await getBase64Async(audio);
|
|
console.debug('MiniMax TTS: Base64 data URL created');
|
|
|
|
// Clean up previous event listener to prevent memory leaks
|
|
this.audioElement.onended = null;
|
|
this.audioElement.onerror = null;
|
|
|
|
this.audioElement.src = srcUrl;
|
|
this.audioElement.volume = Math.min(this.settings.volume || 1.0, 1.0); // HTML audio element max is 1.0
|
|
|
|
// Add error handler for audio element
|
|
this.audioElement.onerror = (e) => {
|
|
console.error('MiniMax TTS: Audio element error:', e);
|
|
console.error('MiniMax TTS: Audio element error details:', {
|
|
error: this.audioElement.error,
|
|
networkState: this.audioElement.networkState,
|
|
readyState: this.audioElement.readyState,
|
|
src: this.audioElement.src,
|
|
});
|
|
|
|
toastr.error('Audio playback failed. The audio format may not be supported by your browser.');
|
|
};
|
|
|
|
try {
|
|
await this.audioElement.play();
|
|
console.debug('MiniMax TTS: Audio playback started successfully');
|
|
} catch (playError) {
|
|
console.error('MiniMax TTS: Play error:', playError);
|
|
throw new Error(`Audio playback failed: ${playError.message}`);
|
|
}
|
|
|
|
this.audioElement.onended = () => {
|
|
this.audioElement.onended = null;
|
|
this.audioElement.onerror = null;
|
|
};
|
|
|
|
} catch (error) {
|
|
console.error('MiniMax TTS Preview Error:', error);
|
|
toastr.error(`Could not generate preview: ${error.message}`);
|
|
}
|
|
}
|
|
}
|