Pollinations: add as TTS provider

4607132576dce358e544faef5bcd683f16b3211a

Cohee <18619528+Cohee1207@users.noreply.github.com>

Parents: 9a86f8a6bbcb1c93b55ce8669a4374347f8e309a

public/scripts/extensions/tts/index.js+2 -0 Viewed

 import { ChatterboxTtsProvider } from './chatterbox.js';
 import { KokoroTtsProvider } from './kokoro.js';
 import { TtsWebuiProvider } from './tts-webui.js';
+import { PollinationsTtsProvider } from './pollinations.js';
 const UPDATE_INTERVAL = 1000;
 const wrapper = new ModuleWorkerWrapper(moduleWorker);

     Novel: NovelTtsProvider,
     OpenAI: OpenAITtsProvider,
     'OpenAI Compatible': OpenAICompatibleTtsProvider,
+    Pollinations: PollinationsTtsProvider,
     SBVits2: SBVits2TtsProvider,
     Silero: SileroTtsProvider,
     SpeechT5: SpeechT5TtsProvider,

public/scripts/extensions/tts/pollinations.js+151 -0 Viewed

+import { getRequestHeaders } from '../../../script.js';
+import { splitRecursive } from '../../utils.js';
+import { getPreviewString, saveTtsProviderSettings } from './index.js';
+export class PollinationsTtsProvider {
+    settings;
+    voices = [];
+    separator = ' . ';
+    audioElement = document.createElement('audio');
+    defaultSettings = {
+        // TODO: Make this configurable
+        model: 'openai-audio',
+        voiceMap: {},
+    };
+    get settingsHtml() {
+        return '';
+    }
+    onSettingsChange() {
+        this.voices = [];
+        saveTtsProviderSettings();
+    }
+    async loadSettings(settings) {
+        // Populate Provider UI given input settings
+        if (Object.keys(settings).length == 0) {
+            console.info('Using default TTS Provider settings');
+        }
+        // Only accept keys defined in defaultSettings
+        this.settings = this.defaultSettings;
+        for (const key in settings) {
+            if (key in this.settings) {
+                this.settings[key] = settings[key];
+            } else {
+                throw `Invalid setting passed to TTS Provider: ${key}`;
+            }
+        }
+        try {
+            await this.checkReady();
+            console.debug('Pollinations TTS: Settings loaded');
+        } catch {
+            console.debug('Pollinations TTS: Settings loaded, but not ready');
+        }
+    }
+    // Perform a simple readiness check by trying to fetch voiceIds
+    async checkReady() {
+        await this.fetchTtsVoiceObjects();
+    }
+    async onRefreshClick() {
+        await this.checkReady();
+    }
+    //#################//
+    //  TTS Interfaces //
+    //#################//
+    async getVoice(voiceName) {
+        if (this.voices.length == 0) {
+            this.voices = await this.fetchTtsVoiceObjects();
+        }
+        const match = this.voices.filter(
+            voice => voice.name == voiceName || voice.voice_id == voiceName,
+        )[0];
+        if (!match) {
+            throw `TTS Voice name ${voiceName} not found`;
+        }
+        return match;
+    }
+    /**
+     * Generate TTS audio for the given text using the specified voice.
+     * @param {string} text Text to generate
+     * @param {string} voiceId Voice ID
+     * @returns {AsyncGenerator<Response>} Audio response generator
+     */
+    generateTts(text, voiceId) {
+        return this.fetchTtsGeneration(text, voiceId);
+    }
+    //###########//
+    // API CALLS //
+    //###########//
+    async fetchTtsVoiceObjects() {
+        const response = await fetch('/api/speech/pollinations/voices', {
+            method: 'POST',
+            headers: getRequestHeaders(),
+            body: JSON.stringify({ model: this.settings.model }),
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+        }
+        const responseJson = await response.json();
+        return responseJson
+            .sort()
+            .map(x => ({ name: x, voice_id: x, preview_url: false, lang: 'en-US' }));
+    }
+    /**
+     * Preview TTS for a given voice ID.
+     * @param {string} id Voice ID
+     */
+    async previewTtsVoice(id) {
+        this.audioElement.pause();
+        this.audioElement.currentTime = 0;
+        const voice = await this.getVoice(id);
+        const text = getPreviewString(voice.lang);
+        for await (const response of this.generateTts(text, id)) {
+            const audio = await response.blob();
+            const url = URL.createObjectURL(audio);
+            await new Promise(resolve => {
+                const audioElement = new Audio();
+                audioElement.src = url;
+                audioElement.play();
+                audioElement.onended = () => resolve();
+            });
+            URL.revokeObjectURL(url);
+        }
+    }
+    async* fetchTtsGeneration(text, voiceId) {
+        const MAX_LENGTH = 1000;
+        console.info(`Generating new TTS for voice_id ${voiceId}`);
+        const chunks = splitRecursive(text, MAX_LENGTH);
+        for (const chunk of chunks) {
+            const response = await fetch('/api/speech/pollinations/generate', {
+                method: 'POST',
+                headers: getRequestHeaders(),
+                body: JSON.stringify({
+                    model: this.settings.model,
+                    text: 'Say exactly this and nothing else:' + '\n' + chunk,
+                    voice: voiceId,
+                }),
+            });
+            if (!response.ok) {
+                toastr.error(response.statusText, 'TTS Generation Failed');
+                throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+            }
+            yield response;
+        }
+    }
+}

src/endpoints/speech.js+61 -0 Viewed

 import { Buffer } from 'node:buffer';
 import express from 'express';
 import wavefile from 'wavefile';
+import fetch from 'node-fetch';
 import { getPipeline } from '../transformers.js';
+import { forwardFetchResponse } from '../util.js';
 export const router = express.Router();

         return res.sendStatus(500);
+    }
 });
+const pollinations = express.Router();
+pollinations.post('/voices', async (req, res) => {
+    try {
+        const model = req.body.model || 'openai-audio';
+        const response = await fetch('https://text.pollinations.ai/models');
+        if (!response.ok) {
+            throw new Error('Failed to fetch Pollinations models');
+        }
+        const data = await response.json();
+        if (!Array.isArray(data)) {
+            throw new Error('Invalid data format received from Pollinations');
+        }
+        const audioModelData = data.find(m => m.name === model);
+        if (!audioModelData || !Array.isArray(audioModelData.voices)) {
+            throw new Error('No voices found for the specified model');
+        }
+        const voices = audioModelData.voices;
+        return res.json(voices);
+    } catch (error) {
+        console.error(error);
+        return res.sendStatus(500);
+    }
+});
+pollinations.post('/generate', async (req, res) => {
+    try {
+        const text = req.body.text;
+        const model = req.body.model || 'openai-audio';
+        const voice = req.body.voice || 'alloy';
+        const url = new URL(`https://text.pollinations.ai/generate/${encodeURIComponent(text)}`);
+        url.searchParams.append('model', model);
+        url.searchParams.append('voice', voice);
+        url.searchParams.append('referrer', 'sillytavern');
+        const response = await fetch(url);
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Failed to generate audio from Pollinations: ${text}`);
+        }
+        res.set('Content-Type', 'audio/mpeg');
+        forwardFetchResponse(response, res);
+    } catch (error) {
+        console.error(error);
+        return res.sendStatus(500);
+    }
+});
+router.use('/pollinations', pollinations);