@qvac/sdk 0.10.2 → 0.12.0

package/dist/server/bare/plugins/onnx-tts/plugin.js

@@ -1,266 +0,0 @@
-import path from "bare-path";
-import ttsAddonLogging from "@qvac/tts-onnx/addonLogging.js";
-import ONNXTTS from "@qvac/tts-onnx";
-import { definePlugin, defineHandler, defineDuplexHandler, ttsRequestSchema, ttsResponseSchema, textToSpeechStreamRequestSchema, textToSpeechStreamResponseSchema, ModelType, ttsConfigSchema, ADDON_TTS, } from "../../../../schemas/index.js";
-import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
-import { TtsArtifactsRequiredError, TtsReferenceAudioRequiredError, } from "../../../../utils/errors-server.js";
-import { textToSpeech } from "./ops/text-to-speech.js";
-import { textToSpeechStream } from "./ops/text-to-speech-stream.js";
-import { attachModelExecutionMs } from "../../../../profiling/model-execution.js";
-import { loadReferenceAudioAt24k } from "./wav-helper.js";
-async function resolveChatterboxConfig(config, ctx) {
-    const { ttsTokenizerSrc, ttsSpeechEncoderSrc, ttsEmbedTokensSrc, ttsConditionalDecoderSrc, ttsLanguageModelSrc, referenceAudioSrc, language, } = config;
-    if (!ttsTokenizerSrc ||
-        !ttsSpeechEncoderSrc ||
-        !ttsEmbedTokensSrc ||
-        !ttsConditionalDecoderSrc ||
-        !ttsLanguageModelSrc) {
-        throw new TtsArtifactsRequiredError();
-    }
-    if (!referenceAudioSrc) {
-        throw new TtsReferenceAudioRequiredError();
-    }
-    const resolve = ctx.resolveModelPath;
-    const [tokenizerPath, speechEncoderPath, embedTokensPath, conditionalDecoderPath, languageModelPath, referenceAudioPath,] = await Promise.all([
-        resolve(ttsTokenizerSrc),
-        resolve(ttsSpeechEncoderSrc),
-        resolve(ttsEmbedTokensSrc),
-        resolve(ttsConditionalDecoderSrc),
-        resolve(ttsLanguageModelSrc),
-        resolve(referenceAudioSrc),
-    ]);
-    return {
-        config: {
-            ttsEngine: "chatterbox",
-            language,
-        },
-        artifacts: {
-            tokenizerPath,
-            speechEncoderPath,
-            embedTokensPath,
-            conditionalDecoderPath,
-            languageModelPath,
-            referenceAudioPath,
-        },
-    };
-}
-async function resolveSupertonicConfig(config, ctx) {
-    const { ttsTextEncoderSrc, ttsDurationPredictorSrc, ttsVectorEstimatorSrc, ttsVocoderSrc, ttsUnicodeIndexerSrc, ttsTtsConfigSrc, ttsVoiceStyleSrc, ttsSpeed, ttsNumInferenceSteps, ttsSupertonicMultilingual, language, } = config;
-    if (!ttsTextEncoderSrc ||
-        !ttsDurationPredictorSrc ||
-        !ttsVectorEstimatorSrc ||
-        !ttsVocoderSrc ||
-        !ttsUnicodeIndexerSrc ||
-        !ttsTtsConfigSrc ||
-        !ttsVoiceStyleSrc) {
-        throw new TtsArtifactsRequiredError();
-    }
-    const resolve = ctx.resolveModelPath;
-    const [textEncoderPath, durationPredictorPath, vectorEstimatorPath, vocoderPath, unicodeIndexerPath, ttsConfigPath, voiceStylePath,] = await Promise.all([
-        resolve(ttsTextEncoderSrc),
-        resolve(ttsDurationPredictorSrc),
-        resolve(ttsVectorEstimatorSrc),
-        resolve(ttsVocoderSrc),
-        resolve(ttsUnicodeIndexerSrc),
-        resolve(ttsTtsConfigSrc),
-        resolve(ttsVoiceStyleSrc),
-    ]);
-    return {
-        config: {
-            ttsEngine: "supertonic",
-            language,
-            ttsSpeed,
-            ttsNumInferenceSteps,
-            ttsSupertonicMultilingual,
-        },
-        artifacts: {
-            textEncoderPath,
-            durationPredictorPath,
-            vectorEstimatorPath,
-            vocoderPath,
-            unicodeIndexerPath,
-            ttsConfigPath,
-            voiceStylePath,
-        },
-    };
-}
-function createChatterboxModel(modelId, config, artifacts) {
-    const tokenizerPath = artifacts["tokenizerPath"];
-    const speechEncoderPath = artifacts["speechEncoderPath"];
-    const embedTokensPath = artifacts["embedTokensPath"];
-    const conditionalDecoderPath = artifacts["conditionalDecoderPath"];
-    const languageModelPath = artifacts["languageModelPath"];
-    const referenceAudioPath = artifacts["referenceAudioPath"];
-    if (!tokenizerPath ||
-        !speechEncoderPath ||
-        !embedTokensPath ||
-        !conditionalDecoderPath ||
-        !languageModelPath) {
-        throw new TtsArtifactsRequiredError();
-    }
-    if (!referenceAudioPath) {
-        throw new TtsReferenceAudioRequiredError();
-    }
-    const logger = createStreamLogger(modelId, ModelType.onnxTts);
-    registerAddonLogger(modelId, ModelType.onnxTts, logger);
-    const referenceAudio = loadReferenceAudioAt24k(referenceAudioPath);
-    const model = new ONNXTTS({
-        files: {
-            tokenizerPath,
-            speechEncoderPath,
-            embedTokensPath,
-            conditionalDecoderPath,
-            languageModelPath,
-        },
-        engine: "chatterbox",
-        config: { language: config.language ?? "en", useGPU: false },
-        referenceAudio,
-        logger,
-        opts: { stats: true },
-        exclusiveRun: true,
-    });
-    return { model };
-}
-function createSupertonicModel(modelId, config, artifacts) {
-    const textEncoderPath = artifacts["textEncoderPath"];
-    const durationPredictorPath = artifacts["durationPredictorPath"];
-    const vectorEstimatorPath = artifacts["vectorEstimatorPath"];
-    const vocoderPath = artifacts["vocoderPath"];
-    const unicodeIndexerPath = artifacts["unicodeIndexerPath"];
-    const ttsConfigPath = artifacts["ttsConfigPath"];
-    const voiceStylePath = artifacts["voiceStylePath"];
-    if (!textEncoderPath ||
-        !durationPredictorPath ||
-        !vectorEstimatorPath ||
-        !vocoderPath ||
-        !unicodeIndexerPath ||
-        !ttsConfigPath ||
-        !voiceStylePath) {
-        throw new TtsArtifactsRequiredError();
-    }
-    const logger = createStreamLogger(modelId, ModelType.onnxTts);
-    registerAddonLogger(modelId, ModelType.onnxTts, logger);
-    const voiceName = path.basename(voiceStylePath).replace(/\.json$/i, "") || "F1";
-    const model = new ONNXTTS({
-        files: {
-            textEncoderPath,
-            durationPredictorPath,
-            vectorEstimatorPath,
-            vocoderPath,
-            unicodeIndexerPath,
-            ttsConfigPath,
-            voiceStyleJsonPath: voiceStylePath,
-        },
-        engine: "supertonic",
-        voiceName,
-        speed: config.ttsSpeed ?? 1,
-        numInferenceSteps: config.ttsNumInferenceSteps ?? 5,
-        supertonicMultilingual: config.ttsSupertonicMultilingual !== false,
-        config: { language: config.language ?? "en" },
-        logger,
-        opts: { stats: true },
-        exclusiveRun: true,
-    });
-    return { model };
-}
-export const ttsPlugin = definePlugin({
-    modelType: ModelType.onnxTts,
-    displayName: "TTS (ONNX)",
-    addonPackage: ADDON_TTS,
-    loadConfigSchema: ttsConfigSchema,
-    skipPrimaryModelPathValidation: true,
-    async resolveConfig(cfg, ctx) {
-        const { ttsEngine } = cfg;
-        if (ttsEngine === "supertonic") {
-            return resolveSupertonicConfig(cfg, ctx);
-        }
-        return resolveChatterboxConfig(cfg, ctx);
-    },
-    createModel(params) {
-        const config = (params.modelConfig ?? {});
-        const artifacts = params.artifacts ?? {};
-        if (config.ttsEngine === "supertonic") {
-            return createSupertonicModel(params.modelId, config, artifacts);
-        }
-        return createChatterboxModel(params.modelId, config, artifacts);
-    },
-    handlers: {
-        textToSpeech: defineHandler({
-            requestSchema: ttsRequestSchema,
-            responseSchema: ttsResponseSchema,
-            streaming: true,
-            handler: async function* (request) {
-                const stream = textToSpeech(request);
-                try {
-                    let result = await stream.next();
-                    while (!result.done) {
-                        yield {
-                            type: "textToSpeech",
-                            buffer: result.value.buffer,
-                            done: false,
-                            ...(result.value.chunkIndex !== undefined
-                                ? { chunkIndex: result.value.chunkIndex }
-                                : {}),
-                            ...(typeof result.value.sentenceChunk === "string" &&
-                                result.value.sentenceChunk.length > 0
-                                ? { sentenceChunk: result.value.sentenceChunk }
-                                : {}),
-                        };
-                        result = await stream.next();
-                    }
-                    const { modelExecutionMs, stats } = result.value;
-                    yield attachModelExecutionMs({
-                        type: "textToSpeech",
-                        buffer: [],
-                        done: true,
-                        ...(stats && { stats }),
-                    }, modelExecutionMs);
-                }
-                finally {
-                    await stream.return?.(undefined);
-                }
-            },
-        }),
-        textToSpeechStream: defineDuplexHandler({
-            requestSchema: textToSpeechStreamRequestSchema,
-            responseSchema: textToSpeechStreamResponseSchema,
-            streaming: true,
-            duplex: true,
-            handler: async function* (request, inputStream) {
-                const stream = textToSpeechStream(request, inputStream);
-                try {
-                    let result = await stream.next();
-                    while (!result.done) {
-                        yield {
-                            type: "textToSpeechStream",
-                            buffer: result.value.buffer,
-                            done: false,
-                            ...(result.value.chunkIndex !== undefined
-                                ? { chunkIndex: result.value.chunkIndex }
-                                : {}),
-                            ...(typeof result.value.sentenceChunk === "string" &&
-                                result.value.sentenceChunk.length > 0
-                                ? { sentenceChunk: result.value.sentenceChunk }
-                                : {}),
-                        };
-                        result = await stream.next();
-                    }
-                    const { modelExecutionMs, stats } = result.value;
-                    yield attachModelExecutionMs({
-                        type: "textToSpeechStream",
-                        buffer: [],
-                        done: true,
-                        ...(stats && { stats }),
-                    }, modelExecutionMs);
-                }
-                finally {
-                    await stream.return?.(undefined);
-                }
-            },
-        }),
-    },
-    logging: {
-        module: ttsAddonLogging,
-        namespace: ModelType.onnxTts,
-    },
-});

package/dist/server/bare/plugins/onnx-tts/wav-helper.d.ts

@@ -1,14 +0,0 @@
-export type ReadWavResult = {
-    samples: Float32Array;
-    sampleRate: number;
-};
-/**
- * Read a WAV file and return Float32Array of mono samples in [-1, 1].
- * Supports 16-bit PCM and 32-bit float; stereo is converted to mono (left channel).
- */
-export declare function readWavAsFloat32(wavPath: string): ReadWavResult;
-/**
- * Load reference audio from a WAV path and return Float32Array at 24kHz for Chatterbox.
- */
-export declare function loadReferenceAudioAt24k(wavPath: string): Float32Array;
-//# sourceMappingURL=wav-helper.d.ts.map

package/dist/server/bare/plugins/onnx-tts/wav-helper.js

@@ -1,107 +0,0 @@
-import fs from "bare-fs";
-const CHATTERBOX_SAMPLE_RATE = 24000;
-/**
- * Read a WAV file and return Float32Array of mono samples in [-1, 1].
- * Supports 16-bit PCM and 32-bit float; stereo is converted to mono (left channel).
- */
-export function readWavAsFloat32(wavPath) {
-    const buf = fs.readFileSync(wavPath);
-    if (buf.length < 44)
-        throw new Error("WAV file too small");
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    const riff = String.fromCharCode(buf[0], buf[1], buf[2], buf[3]);
-    const wave = String.fromCharCode(buf[8], buf[9], buf[10], buf[11]);
-    if (riff !== "RIFF")
-        throw new Error("Not a RIFF file");
-    if (wave !== "WAVE")
-        throw new Error("Not WAVE format");
-    let fmtChunk = null;
-    let dataChunk = null;
-    let offset = 12;
-    while (offset + 8 <= buf.length) {
-        const chunkId = String.fromCharCode(buf[offset], buf[offset + 1], buf[offset + 2], buf[offset + 3]);
-        const chunkSize = view.getUint32(offset + 4, true);
-        if (chunkId === "fmt ")
-            fmtChunk = { offset: offset + 8, size: chunkSize };
-        else if (chunkId === "data")
-            dataChunk = { offset: offset + 8, size: chunkSize };
-        offset += 8 + chunkSize;
-        if (chunkSize % 2 === 1 && offset < buf.length)
-            offset += 1;
-    }
-    if (!fmtChunk)
-        throw new Error("WAV missing fmt chunk");
-    if (!dataChunk)
-        throw new Error("WAV missing data chunk");
-    const fmtOff = fmtChunk.offset;
-    if (fmtOff + 16 > buf.length)
-        throw new Error("fmt chunk truncated");
-    const audioFormat = view.getUint16(fmtOff, true);
-    const numChannels = view.getUint16(fmtOff + 2, true);
-    const sampleRate = view.getUint32(fmtOff + 4, true);
-    const bitsPerSample = view.getUint16(fmtOff + 14, true);
-    if (audioFormat !== 1 && audioFormat !== 3) {
-        throw new Error("Unsupported WAV audio format: " +
-            audioFormat +
-            " (only PCM=1 and IEEE_FLOAT=3 supported)");
-    }
-    const dataOff = dataChunk.offset;
-    const dataLen = Math.min(dataChunk.size, buf.length - dataOff);
-    let samples;
-    if (audioFormat === 1 && bitsPerSample === 16) {
-        const bytesPerSample = 2;
-        const numSamples = Math.floor(dataLen / bytesPerSample);
-        const numFrames = numChannels === 1 ? numSamples : Math.floor(numSamples / numChannels);
-        samples = new Float32Array(numFrames);
-        for (let i = 0; i < numFrames; i++) {
-            const idx = dataOff + (numChannels === 1 ? i * 2 : i * numChannels * 2);
-            if (idx + 2 > buf.length)
-                break;
-            const s = view.getInt16(idx, true);
-            samples[i] = s / 32768;
-        }
-    }
-    else if (audioFormat === 3 && bitsPerSample === 32) {
-        const bytesPerSample = 4;
-        const numSamples = Math.floor(dataLen / bytesPerSample);
-        const numFrames = numChannels === 1 ? numSamples : Math.floor(numSamples / numChannels);
-        samples = new Float32Array(numFrames);
-        for (let i = 0; i < numFrames; i++) {
-            const idx = dataOff + (numChannels === 1 ? i * 4 : i * numChannels * 4);
-            if (idx + 4 > buf.length)
-                break;
-            samples[i] = view.getFloat32(idx, true);
-        }
-    }
-    else {
-        throw new Error("Unsupported WAV format: audioFormat=" +
-            audioFormat +
-            ", bitsPerSample=" +
-            bitsPerSample);
-    }
-    return { samples, sampleRate };
-}
-function resampleLinear(samples, fromRate, toRate) {
-    if (fromRate === toRate)
-        return samples;
-    const ratio = fromRate / toRate;
-    const outputLen = Math.round(samples.length / ratio);
-    const output = new Float32Array(outputLen);
-    for (let i = 0; i < outputLen; i++) {
-        const srcIdx = i * ratio;
-        const lo = Math.floor(srcIdx);
-        const hi = Math.min(lo + 1, samples.length - 1);
-        const frac = srcIdx - lo;
-        output[i] = samples[lo] * (1 - frac) + samples[hi] * frac;
-    }
-    return output;
-}
-/**
- * Load reference audio from a WAV path and return Float32Array at 24kHz for Chatterbox.
- */
-export function loadReferenceAudioAt24k(wavPath) {
-    const { samples, sampleRate } = readWavAsFloat32(wavPath);
-    if (sampleRate === CHATTERBOX_SAMPLE_RATE)
-        return samples;
-    return resampleLinear(samples, sampleRate, CHATTERBOX_SAMPLE_RATE);
-}