woolball-client/dist/utils/tasks/ai/tts.js

Client-side library for Woolball enabling secure browser resource sharing for distributed AI task processing

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.tts = tts;
const media_1 = require("../../media");
const SUPPORTED_MODEL_PREFIXES = ['xenova/mms-tts-', 'onnx-community/kokoro'];
async function tts(data) {
    const { input, model, dtype, provider = 'transformers', ...options } = data;
    try {
        const isSupportedModel = SUPPORTED_MODEL_PREFIXES.some(prefix => model.toLowerCase().includes(prefix.toLowerCase()));
        if (!isSupportedModel) {
            console.warn('Model not explicitly recognized, trying to process:', model);
        }
        if (provider === 'kokoro') {
            return await processKokoroTTS(input, model, dtype, options);
        }
        else {
            return await processTransformersTTS(input, model, dtype, options);
        }
    }
    catch (error) {
        console.error('Error in tts():', error);
        const errorMessage = error instanceof Error ?
            error.message :
            'Unknown error in text-to-speech processing';
        console.error('TTS error details:', errorMessage);
        if (error instanceof Error && error.stack) {
            console.error('Stack trace:', error.stack);
        }
        throw error;
    }
}
async function processTransformersTTS(text, model, dtype, options = {}) {
    try {
        const { pipeline, env } = await import('@huggingface/transformers');
        env.allowLocalModels = false;
        const { getTransformersDevice } = await import('../../../utils/environment.js');
        const pipe = await pipeline('text-to-speech', model, {
            dtype: dtype,
            device: getTransformersDevice('wasm'),
        });
        const result = await pipe(text, options);
        const wavEncoder = await import('wav-encoder');
        const wavBuffer = await wavEncoder.encode({
            sampleRate: 16000,
            channelData: [Array.isArray(result.audio) ? result.audio[0] : result.audio]
        });
        await pipe.dispose();
        return {
            audio: (0, media_1.bufferToBase64)(wavBuffer)
        };
    }
    catch (error) {
        console.error('Error in processTransformersTTS:', error);
        // Generic error messages for any problem
        if (error instanceof Error) {
            if (error.message.includes('Unsupported model type') ||
                error.message.includes('AutoModel')) {
                console.error('Unsupported model type error');
                throw new Error(`Unsupported model type: ${model}. Please use Xenova/mms-tts-* or Kokoro.`);
            }
        }
        throw error;
    }
}
async function processKokoroTTS(text, model, dtype, options = {}) {
    try {
        const { KokoroTTS } = await import('kokoro-js');
        const tts = await KokoroTTS.from_pretrained(model, { dtype: dtype || 'q8' });
        const audio = await tts.generate(text, {
            voice: options.voice
        });
        const audioBlob = audio.toBlob();
        const arrayBuffer = await (0, media_1.blobToArrayBuffer)(audioBlob);
        const base64Audio = (0, media_1.bufferToBase64)(arrayBuffer);
        return {
            audio: base64Audio
        };
    }
    catch (error) {
        console.error('Error in processKokoroTTS:', error);
        throw error;
    }
}