utilitas 2000.3.27 → 2000.3.28

package/lib/speech.mjs

@@ -1,36 +1,20 @@
-import { DEFAULT_MODELS, OPENAI_VOICE, countTokens, k } from './alan.mjs';
-import { getFfmpeg, packPcmToWav } from './media.mjs';
 import { get } from './web.mjs';
-import { convert, getTempPath } from './storage.mjs';
-import { ensureString, mergeAtoB } from './utilitas.mjs';
+import { getFfmpeg } from './media.mjs';
+import { getTempPath } from './storage.mjs';
+import { hash } from './encryption.mjs';
 
 import {
-    call, countKeys, ignoreErrFunc, inBrowser,
-    need, throwError
+    call, ignoreErrFunc, inBrowser, need, throwError,
 } from './utilitas.mjs';
 
 import {
-    convertAudioTo16kNanoOpusOgg,
-    convertAudioTo16kNanoPcmWave,
+    convertAudioTo16kNanoOpusOgg, convertAudioTo16kNanoPcmWave,
 } from './media.mjs';
 
-const _NEED = ['@google/genai', 'OpenAI', 'whisper-node'];
+const _NEED = ['whisper-node'];
 
-const [
-    BUFFER, STREAM, BASE64, FILE, clients, suffix, SPEAKER, cleanup, wav,
-    GPT_4O_MIMI_TTS, GPT_4O_TRANSCRIBE, GEMINI_25_FLASH_TTS,
-    OPENAI_TTS_MAX_LENGTH, WHISPER_DEFAULT_MODEL, errorMessage
-] = [
-        'BUFFER', 'STREAM', 'BASE64', 'FILE', {}, 'ogg', 'SPEAKER', true, 'wav',
-        'gpt-4o-mini-tts', 'gpt-4o-transcribe', 'gemini-2.5-flash-preview-tts',
-        4096, 'base', 'Invalid audio data.',
-    ];
-
-const [
-    defaultOpenAITtsModel, defaultOpenAISttModel, defaultGeminiTtsModel,
-] = [GPT_4O_MIMI_TTS, GPT_4O_TRANSCRIBE, GEMINI_25_FLASH_TTS];
-
-const TTS_PROMPT = "As an AI voice assistant, please say the following content in a warm, friendly and professional tone, if the language is English, use an American accent, if it's Traditional Chinese, use Hong Kong Cantonese, if it's Simplified Chinese, use standard Mandarin, for other languages, please speak with a standard, clear accent";
+const [FILE, suffix, SPEAKER, cleanup, WHISPER_DEFAULT_MODEL, errorMessage]
+    = ['FILE', 'ogg', 'SPEAKER', true, 'base', 'Invalid audio data.'];
 
 const WHISPER_MODELS = [
     // npx whisper-node download tiny.en
@@ -83,105 +67,22 @@ const getWhisperModelReady = async (model, options) => {
     return (await get(getWhisperModelUrl(model), { fuzzy: true }))?.cache?.content;
 };
 
-const init = async (options) => {
-    if (options) {
-        assert(
-            options?.tts || options?.stt,
-            'At least one of TTS or STT is selected.', 500
-        );
-        const provider = ensureString(options?.provider, { case: 'UP' });
-        switch (provider) {
-            case 'OPENAI':
-                clients._provider = provider;
-                const OpenAI = await need('openai');
-                const openai = new OpenAI(options);
-                if (options?.tts) {
-                    clients.tts = openai.audio.speech;
-                }
-                if (options?.stt) {
-                    clients.stt = openai.audio.transcriptions;
-                    clients.toFile = OpenAI.toFile;
-                }
-                break;
-            case 'GOOGLE':
-                clients._provider = provider;
-                const { GoogleGenAI } = await need('@google/genai');
-                const client = new GoogleGenAI(options);
-                if (options?.tts) {
-                    clients.tts = client.models.generateContent;
-                }
-                break;
-            case '':
-                clients._provider = 'LOCAL';
-                options?.tts && await checkSay({ assert: true });
-                options?.stt && await checkWhisper({ assert: true });
-                break;
-            default:
-                throwError('Invalid speech provider.', 500);
-        }
-    }
-    assert(
-        countKeys(clients), 'Speech API client has not been initialized.', 501
-    );
-    return clients;
-};
-
-const checkSay = async (options) => {
+const checkSay = async () => {
     const result = !!(await ignoreErrFunc(async () => (
         await Promise.all([need('node:os'), need('say'), getFfmpeg()])
     )[0].platform() === 'darwin'));
-    options?.assert && assert(result, 'Say API is not available.', 500);
+    assert(result, 'Say API is not available.', 500);
     return result;
 };
 
-const checkWhisper = async (options) => {
+const checkWhisper = async () => {
     const result = !!(await ignoreErrFunc(() => Promise.all([
         need('whisper-node'), getFfmpeg()
     ])));
-    options?.assert && assert(result, 'Whisper API is not available.', 500);
+    assert(result, 'Whisper API is not available.', 500);
     return result;
 };
 
-const ttsOpenAI = async (input, options) => {
-    assert(clients.tts, 'OpenAI TTS API has not been initialized.', 500);
-    assert(input, 'Text is required.', 400);
-    assert(input.length <= OPENAI_TTS_MAX_LENGTH, 'Text is too long.', 400);
-    // https://platform.openai.com/docs/api-reference/audio/createSpeech
-    const content = await clients.tts.create({
-        model: defaultOpenAITtsModel, voice: DEFAULT_MODELS[OPENAI_VOICE],
-        instructions: 'Speak in a friendly and sweet tone.',
-        response_format: 'opus', input, ...options?.params || {},
-    });
-    const buffer = Buffer.from(await content.arrayBuffer());
-    return await convert(buffer, { suffix, ...options || {} });
-};
-
-// https://ai.google.dev/gemini-api/docs/speech-generation#voices
-const ttsGoogle = async (contents, options) => {
-    assert(clients.tts, 'Google TTS API has not been initialized.', 500);
-    assert(contents, 'Text is required.', 400);
-    assert(await countTokens(contents) <= k(32), 'Text is too long.', 400);
-    const resp = await clients.tts({
-        model: options?.model || defaultGeminiTtsModel,
-        contents: `${options?.prompt || TTS_PROMPT}: ${contents}`,
-        config: mergeAtoB(options?.config, {
-            responseModalities: ['AUDIO'],
-            speechConfig: {
-                voiceConfig: {
-                    prebuiltVoiceConfig: {
-                        voiceName: options?.voice || 'Zephyr',
-                    },
-                },
-            },
-        }),
-    });
-    const rawAudio = resp?.candidates?.[0]?.content?.parts?.[0]?.inlineData;
-    assert(rawAudio, 'Failed to generate audio.', 500);
-    return options?.raw ? rawAudio : await packPcmToWav(rawAudio?.data, {
-        input: BASE64, expected: 'FILE', suffix: wav, ...options || {},
-    });
-};
-
 const ttsSay = async (text, options) => {
     const say = await need('say');
     assert(text, 'Text is required.', 400);
@@ -208,22 +109,6 @@ const ttsBrowser = async (text) => {
     return speechSynthesis.speak(new SpeechSynthesisUtterance(text));
 };
 
-const sttOpenAI = async (audio, options) => {
-    assert(clients.stt, 'OpenAI STT API has not been initialized.', 500);
-    const input = ensureString(options?.input, { case: 'UP' });
-    const { content, cleanup } = await convert(audio, {
-        input: options?.input, ...options || {}, expected: STREAM, errorMessage,
-        suffix: ['', BUFFER].includes(input) ? suffix : null,
-        withCleanupFunc: true,
-    });
-    const result = await clients.stt.create({
-        file: await clients.toFile(content), model: defaultOpenAISttModel,
-        response_format: 'text', ...options?.params || {},
-    });
-    await cleanup();
-    return result;
-};
-
 // This function is not working properly, a pull request is filed:
 // https://github.com/ariym/whisper-node/pull/58
 const sttWhisper = async (audio, options) => {
@@ -253,33 +138,24 @@ const sttWhisper = async (audio, options) => {
 const tts = async (text, options) => {
     let engine;
     if (inBrowser()) { engine = ttsBrowser }
-    else if (clients?.tts && clients._provider === 'GOOGLE') { engine = ttsGoogle; }
-    else if (clients?.tts && clients._provider === 'OPENAI') { engine = ttsOpenAI; }
     else if (await checkSay()) { engine = ttsSay; }
-    else { throwError('Text-to-Speech engine has not been initialized.', 500); }
+    else { throwError('Text-to-Speech engine is not available.', 500); }
     return await engine(text, options);
 };
 
 const stt = async (audio, options) => {
     let engine;
-    if (clients?.stt && clients._provider === 'OPENAI') { engine = sttOpenAI; }
-    else if (await checkWhisper()) { engine = sttWhisper; }
-    else { throwError('Speech-to-Text engine has not been initialized.', 500); }
+    if (await checkWhisper()) { engine = sttWhisper; }
+    else { throwError('Speech-to-Text engine is not available.', 500); }
     return await engine(audio, options);
 };
 
-export default init;
 export {
     _NEED,
-    OPENAI_TTS_MAX_LENGTH,
     checkSay,
     checkWhisper,
-    init,
     stt,
-    sttOpenAI,
     sttWhisper,
     tts,
-    ttsGoogle,
-    ttsOpenAI,
     ttsSay,
 };

package/lib/storage.mjs

@@ -240,7 +240,7 @@ const blobToBuffer = async blob => {
 
 const convert = async (any, options) => {
     assert(any, options?.errorMessage || 'Invalid input.', 400);
-    const result = {}
+    let result = {};
     let [input, expected] = [(
         Buffer.isBuffer(any)
         || ArrayBuffer.isArrayBuffer(any)
@@ -248,7 +248,7 @@ const convert = async (any, options) => {
     ) ? BUFFER : options?.input, options?.expected || BUFFER].map(
         x => ensureString(x, { case: 'UP' })
     );
-    let [oriFile, meta, mime, subExp] = [null, null, MIME_BINARY, expected];
+    let [oriFile, meta, mime, subExp] = [null, null, null, expected];
     switch (input) {
         case FILE:
             oriFile = any;
@@ -269,6 +269,7 @@ const convert = async (any, options) => {
             input = BUFFER;
             break;
     }
+    mime || (mime = (await getMime(any, any))?.mime || MIME_BINARY);
     switch (expected) {
         case STREAM: subExp = FILE; break;
         case DATAURL: subExp = BUFFER; break;
@@ -313,8 +314,9 @@ const convert = async (any, options) => {
 
 const getMime = async (buf, filename) => {
     const mimeType = await ignoreErrFunc(() => need('mime-types'));
-    const mime = extract(await fileTypeFromBuffer(buf), 'mime')
-        || (filename && mimeType?.lookup?.(filename)) || MIME_BINARY;
+    const mime = (buf && Buffer.isBuffer(buf) && extract(await fileTypeFromBuffer(buf), 'mime'))
+        || (filename && String.isString(filename) && mimeType?.lookup?.(filename))
+        || MIME_BINARY;
     return { mime, extension: mimeType?.extension?.(mime) || 'bin' };
 };
 

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "utilitas",
     "description": "Just another common utility for JavaScript.",
-    "version": "2000.3.27",
+    "version": "2000.3.28",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",