@qvac/sdk 0.14.1 → 0.16.0

package/dist/server/bare/plugins/sdcpp-generation/plugin.js

@@ -1,11 +1,13 @@
-import ImgStableDiffusion, { EsrganUpscaler, VideoStableDiffusion, } from "@qvac/diffusion-cpp";
-import addonLogging from "@qvac/diffusion-cpp/addonLogging.js";
-import { definePlugin, defineHandler, sdcppConfigSchema, diffusionRequestSchema, diffusionStreamResponseSchema, videoRequestSchema, videoStreamResponseSchema, upscaleRequestSchema, upscaleStreamResponseSchema, ModelType, ADDON_DIFFUSION, } from "../../../../schemas/index.js";
-import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
-import { ModelLoadFailedError } from "../../../../utils/errors-server.js";
-import { diffusion } from "./ops/diffusion.js";
-import { video } from "./ops/video.js";
-import { upscale } from "./ops/upscale.js";
+import ImgStableDiffusion, { EsrganUpscaler, VideoStableDiffusion } from '@qvac/diffusion-cpp';
+import addonLogging from '@qvac/diffusion-cpp/addonLogging.js';
+import { definePlugin, defineHandler, sdcppConfigSchema, diffusionRequestSchema, diffusionStreamResponseSchema, videoRequestSchema, videoStreamResponseSchema, upscaleRequestSchema, upscaleStreamResponseSchema, ModelType, ADDON_DIFFUSION } from '../../../../schemas/index.js';
+import { createStreamLogger, registerAddonLogger, getServerLogger } from '../../../../logging/index.js';
+import { ModelLoadFailedError } from '../../../../utils/errors-server.js';
+import { isMobile } from '../../registry/runtime-context-registry.js';
+import { stripMultiGpuKeys } from '../../../utils/multi-gpu-mobile.js';
+import { diffusion } from './ops/diffusion.js';
+import { markLtxVideoModel, video } from './ops/video.js';
+import { upscale } from './ops/upscale.js';
 // Single source of truth for `SdcppConfig.upscaler.*` → addon-config key
 // mapping. Used by both the diffusion-mode (post-generation upscaler) and the
 // standalone-upscale-mode branches; keeping the mapping in one place avoids
@@ -15,17 +17,17 @@ function flattenUpscalerKeys(upscaler) {
         return {};
     return {
         ...(upscaler.tile_size !== undefined && {
-            upscaler_tile_size: upscaler.tile_size,
+            upscaler_tile_size: upscaler.tile_size
         }),
         ...(upscaler.direct !== undefined && {
-            upscaler_direct: upscaler.direct,
+            upscaler_direct: upscaler.direct
         }),
         ...(upscaler.offload_params_to_cpu !== undefined && {
-            upscaler_offload_params_to_cpu: upscaler.offload_params_to_cpu,
+            upscaler_offload_params_to_cpu: upscaler.offload_params_to_cpu
         }),
         ...(upscaler.threads !== undefined && {
-            upscaler_threads: upscaler.threads,
-        }),
+            upscaler_threads: upscaler.threads
+        })
     };
 }
 // `mode: "upscale"` builds an EsrganUpscaler directly (not via SdCtx), so the
@@ -35,7 +37,7 @@ function toEsrganAddonConfig(config) {
     return {
         ...flattenUpscalerKeys(config.upscaler),
         ...(config.device !== undefined && { device: config.device }),
-        ...(config.verbosity !== undefined && { verbosity: config.verbosity }),
+        ...(config.verbosity !== undefined && { verbosity: config.verbosity })
     };
 }
 /**
@@ -48,34 +50,66 @@ function toEsrganAddonConfig(config) {
  */
 export const diffusionPlugin = definePlugin({
     modelType: ModelType.sdcppGeneration,
-    displayName: "Image Generation & Upscaling (stable-diffusion.cpp)",
+    displayName: 'Image Generation & Upscaling (stable-diffusion.cpp)',
     addonPackage: ADDON_DIFFUSION,
     loadConfigSchema: sdcppConfigSchema,
     async resolveConfig(cfg, ctx) {
+        if (cfg.uncondModelSrc && cfg.mode !== 'diffusion') {
+            throw new ModelLoadFailedError('modelConfig.uncondModelSrc is Ideogram 4 diffusion only. ' +
+                "Use mode: 'diffusion' or remove uncondModelSrc.");
+        }
+        if (cfg.uncondModelSrc && (!cfg.llmModelSrc || !cfg.vaeModelSrc)) {
+            throw new ModelLoadFailedError('modelConfig.uncondModelSrc selects the Ideogram 4 layout and requires ' +
+                'modelConfig.llmModelSrc (Qwen3-VL) and modelConfig.vaeModelSrc.');
+        }
         // Standalone-upscaler mode never references auxiliary models: the primary
         // modelSrc IS the ESRGAN file. Skip resolution to avoid downloading
         // unused encoders/VAEs and to keep load fast.
-        if (cfg.mode === "upscale") {
+        if (cfg.mode === 'upscale') {
             return { config: cfg };
         }
-        const { clipLModelSrc, clipGModelSrc, clipVisionModelSrc, t5XxlModelSrc, llmModelSrc, vaeModelSrc, highNoiseDiffusionModelSrc, upscaler, ...rest } = cfg;
+        const { clipLModelSrc, clipGModelSrc, clipVisionModelSrc, t5XxlModelSrc, llmModelSrc, vaeModelSrc, highNoiseDiffusionModelSrc, uncondModelSrc, audioVaeModelSrc, embeddingsConnectorsModelSrc, upscaler, ...rest } = cfg;
+        // audioVae / embeddingsConnectors are LTX-2 video companions. Reject them
+        // up front — before any companion download — when the selected layout
+        // can't consume them, instead of silently resolving the file and then
+        // dropping it in createModel. Both fields are new, so this cannot break
+        // existing callers.
+        if (embeddingsConnectorsModelSrc && cfg.mode !== 'video') {
+            throw new ModelLoadFailedError('modelConfig.embeddingsConnectorsModelSrc selects the LTX-2 video ' +
+                "layout and is only valid with mode: 'video'.");
+        }
+        if (audioVaeModelSrc && !(cfg.mode === 'video' && embeddingsConnectorsModelSrc)) {
+            throw new ModelLoadFailedError('modelConfig.audioVaeModelSrc is LTX-2 video only. It requires ' +
+                "mode: 'video' together with modelConfig.embeddingsConnectorsModelSrc " +
+                '(which selects the LTX-2 layout). Add embeddingsConnectorsModelSrc ' +
+                'or remove audioVaeModelSrc.');
+        }
         // Video jobs do not apply ESRGAN so we drop the whole `upscaler` object.
-        const effectiveUpscaler = cfg.mode === "video" ? undefined : upscaler;
+        const effectiveUpscaler = cfg.mode === 'video' ? undefined : upscaler;
         const { model_src: esrganModelSrc, ...upscalerRuntime } = effectiveUpscaler ?? {};
         const runtimeConfig = {
             ...rest,
-            ...(effectiveUpscaler && { upscaler: upscalerRuntime }),
+            ...(effectiveUpscaler && { upscaler: upscalerRuntime })
         };
         const sources = {
-            clipLModelSrc, clipGModelSrc, clipVisionModelSrc, t5XxlModelSrc,
-            llmModelSrc, vaeModelSrc, highNoiseDiffusionModelSrc, esrganModelSrc,
+            clipLModelSrc,
+            clipGModelSrc,
+            clipVisionModelSrc,
+            t5XxlModelSrc,
+            llmModelSrc,
+            vaeModelSrc,
+            highNoiseDiffusionModelSrc,
+            uncondModelSrc,
+            audioVaeModelSrc,
+            embeddingsConnectorsModelSrc,
+            esrganModelSrc
         };
         const hasSources = Object.values(sources).some(Boolean);
         if (!hasSources) {
             return { config: runtimeConfig };
         }
         const resolve = ctx.resolveModelPath;
-        const [clipLModelPath, clipGModelPath, clipVisionModelPath, t5XxlModelPath, llmModelPath, vaeModelPath, highNoiseDiffusionModelPath, esrganModelPath,] = await Promise.all([
+        const [clipLModelPath, clipGModelPath, clipVisionModelPath, t5XxlModelPath, llmModelPath, vaeModelPath, highNoiseDiffusionModelPath, uncondModelPath, audioVaeModelPath, embeddingsConnectorsModelPath, esrganModelPath] = await Promise.all([
             clipLModelSrc ? resolve(clipLModelSrc) : undefined,
             clipGModelSrc ? resolve(clipGModelSrc) : undefined,
             clipVisionModelSrc ? resolve(clipVisionModelSrc) : undefined,
@@ -83,7 +117,10 @@ export const diffusionPlugin = definePlugin({
             llmModelSrc ? resolve(llmModelSrc) : undefined,
             vaeModelSrc ? resolve(vaeModelSrc) : undefined,
             highNoiseDiffusionModelSrc ? resolve(highNoiseDiffusionModelSrc) : undefined,
-            esrganModelSrc ? resolve(esrganModelSrc) : undefined,
+            uncondModelSrc ? resolve(uncondModelSrc) : undefined,
+            audioVaeModelSrc ? resolve(audioVaeModelSrc) : undefined,
+            embeddingsConnectorsModelSrc ? resolve(embeddingsConnectorsModelSrc) : undefined,
+            esrganModelSrc ? resolve(esrganModelSrc) : undefined
         ]);
         return {
             config: runtimeConfig,
@@ -95,77 +132,118 @@ export const diffusionPlugin = definePlugin({
                 ...(llmModelPath && { llmModelPath }),
                 ...(vaeModelPath && { vaeModelPath }),
                 ...(highNoiseDiffusionModelPath && { highNoiseDiffusionModelPath }),
-                ...(esrganModelPath && { esrganModelPath }),
-            },
+                ...(uncondModelPath && { uncondModelPath }),
+                ...(audioVaeModelPath && { audioVaeModelPath }),
+                ...(embeddingsConnectorsModelPath && { embeddingsConnectorsModelPath }),
+                ...(esrganModelPath && { esrganModelPath })
+            }
         };
     },
     createModel(params) {
         const { modelId, modelPath, modelConfig, artifacts } = params;
         const config = (modelConfig ?? {});
+        // no multi-gpu on mobile
+        if (isMobile()) {
+            const stripped = stripMultiGpuKeys(config);
+            if (stripped.length > 0) {
+                getServerLogger().warn(`[${ModelType.sdcppGeneration}:${modelId}] Multi-GPU parameters (${stripped.join(', ')}) are not supported on mobile (single-GPU device) — removing from config; model will load with single-GPU defaults`);
+            }
+        }
         // In diffusion mode the ESRGAN file (when post-generation upscale is
         // wanted) must come from upscaler.model_src — the primary modelPath is
         // the main diffusion checkpoint. Reject early with a clear error
         // instead of letting the native addon fail mid-load. Done before any
         // logger / native side-effects so callers can recover cleanly.
-        if (config.mode === "diffusion" &&
+        if (config.mode === 'diffusion' &&
             config.upscaler !== undefined &&
-            !artifacts?.["esrganModelPath"]) {
-            throw new ModelLoadFailedError("modelConfig.upscaler.model_src is required when modelConfig.upscaler " +
-                "is set in diffusion mode. Provide the ESRGAN model, omit the " +
+            !artifacts?.['esrganModelPath']) {
+            throw new ModelLoadFailedError('modelConfig.upscaler.model_src is required when modelConfig.upscaler ' +
+                'is set in diffusion mode. Provide the ESRGAN model, omit the ' +
                 "upscaler block, or switch to modelConfig.mode = 'upscale' to load " +
-                "a standalone upscaler.");
+                'a standalone upscaler.');
         }
         const logger = createStreamLogger(modelId, ModelType.sdcppGeneration);
         registerAddonLogger(modelId, ModelType.sdcppGeneration, logger);
-        if (config.mode === "upscale") {
+        if (config.mode === 'upscale') {
             const model = new EsrganUpscaler({
                 files: { esrgan: modelPath },
                 config: toEsrganAddonConfig(config),
                 logger,
-                opts: { stats: true },
+                opts: { stats: true }
             });
             return { model };
         }
-        if (config.mode === "video") {
-            if (!artifacts?.["t5XxlModelPath"]) {
-                throw new ModelLoadFailedError("modelConfig.t5XxlModelSrc is required in video mode. " +
-                    "Provide the Wan text encoder model before loading the video pipeline.");
+        if (config.mode === 'video') {
+            // Layout is selected the same way the addon self-detects it: the
+            // presence of the LTX-2 text-embedding connectors switches from the
+            // Wan layout (UMT5 via t5Xxl) to the LTX-2 layout (Gemma via llm +
+            // video VAE + connectors, optional audio VAE). Mirrors
+            // `SdModel::isLtxModel_ = !embeddingsConnectorsPath.empty()`.
+            const embeddingsConnectorsModelPath = artifacts?.['embeddingsConnectorsModelPath'];
+            if (!artifacts?.['vaeModelPath']) {
+                throw new ModelLoadFailedError('modelConfig.vaeModelSrc is required in video mode. ' +
+                    'Provide the Wan or LTX-2 video VAE model before loading the video pipeline.');
+            }
+            const vaeModelPath = artifacts['vaeModelPath'];
+            let files;
+            if (embeddingsConnectorsModelPath) {
+                if (!artifacts['llmModelPath']) {
+                    throw new ModelLoadFailedError('modelConfig.llmModelSrc is required for LTX-2 video. ' +
+                        'Provide the Gemma text encoder model before loading the LTX-2 pipeline.');
+                }
+                files = {
+                    model: modelPath,
+                    vae: vaeModelPath,
+                    llm: artifacts['llmModelPath'],
+                    embeddingsConnectors: embeddingsConnectorsModelPath,
+                    ...(artifacts['audioVaeModelPath'] && {
+                        audioVae: artifacts['audioVaeModelPath']
+                    }),
+                    ...(artifacts['esrganModelPath'] && { esrgan: artifacts['esrganModelPath'] })
+                };
             }
-            if (!artifacts?.["vaeModelPath"]) {
-                throw new ModelLoadFailedError("modelConfig.vaeModelSrc is required in video mode. " +
-                    "Provide the Wan VAE model before loading the video pipeline.");
+            else {
+                if (!artifacts['t5XxlModelPath']) {
+                    throw new ModelLoadFailedError('modelConfig.t5XxlModelSrc is required in video mode. ' +
+                        'Provide the Wan text encoder model before loading the video pipeline.');
+                }
+                files = {
+                    model: modelPath,
+                    vae: vaeModelPath,
+                    t5Xxl: artifacts['t5XxlModelPath'],
+                    ...(artifacts['highNoiseDiffusionModelPath'] && {
+                        highNoiseDiffusionModel: artifacts['highNoiseDiffusionModelPath']
+                    }),
+                    ...(artifacts['clipVisionModelPath'] && {
+                        clipVision: artifacts['clipVisionModelPath']
+                    }),
+                    ...(artifacts['esrganModelPath'] && { esrgan: artifacts['esrganModelPath'] })
+                };
             }
-            const files = {
-                model: modelPath,
-                t5Xxl: artifacts["t5XxlModelPath"],
-                vae: artifacts["vaeModelPath"],
-                ...(artifacts?.["highNoiseDiffusionModelPath"] && {
-                    highNoiseDiffusionModel: artifacts["highNoiseDiffusionModelPath"],
-                }),
-                ...(artifacts?.["clipVisionModelPath"] && {
-                    clipVision: artifacts["clipVisionModelPath"],
-                }),
-                ...(artifacts?.["esrganModelPath"] && { esrgan: artifacts["esrganModelPath"] }),
-            };
             /* eslint-disable @typescript-eslint/no-unused-vars */
-            const { clipLModelSrc, clipGModelSrc, clipVisionModelSrc, t5XxlModelSrc, llmModelSrc, vaeModelSrc, highNoiseDiffusionModelSrc, upscaler, mode, ...rest } = config;
+            const { clipLModelSrc, clipGModelSrc, clipVisionModelSrc, t5XxlModelSrc, llmModelSrc, vaeModelSrc, highNoiseDiffusionModelSrc, uncondModelSrc, audioVaeModelSrc, embeddingsConnectorsModelSrc, upscaler, mode, ...rest } = config;
             /* eslint-enable @typescript-eslint/no-unused-vars */
             const model = new VideoStableDiffusion({
                 files,
                 config: rest,
                 logger,
-                opts: { stats: true },
+                opts: { stats: true }
             });
+            if (embeddingsConnectorsModelPath)
+                markLtxVideoModel(model);
             return { model };
         }
         const files = {
             model: modelPath,
-            ...(artifacts?.["clipLModelPath"] && { clipL: artifacts["clipLModelPath"] }),
-            ...(artifacts?.["clipGModelPath"] && { clipG: artifacts["clipGModelPath"] }),
-            ...(artifacts?.["t5XxlModelPath"] && { t5Xxl: artifacts["t5XxlModelPath"] }),
-            ...(artifacts?.["llmModelPath"] && { llm: artifacts["llmModelPath"] }),
-            ...(artifacts?.["vaeModelPath"] && { vae: artifacts["vaeModelPath"] }),
-            ...(artifacts?.["esrganModelPath"] && { esrgan: artifacts["esrganModelPath"] }),
+            ...(artifacts?.['clipLModelPath'] && { clipL: artifacts['clipLModelPath'] }),
+            ...(artifacts?.['clipGModelPath'] && { clipG: artifacts['clipGModelPath'] }),
+            ...(artifacts?.['t5XxlModelPath'] && { t5Xxl: artifacts['t5XxlModelPath'] }),
+            ...(artifacts?.['llmModelPath'] && { llm: artifacts['llmModelPath'] }),
+            ...(artifacts?.['vaeModelPath'] && { vae: artifacts['vaeModelPath'] }),
+            ...(artifacts?.['uncondModelPath'] && {
+                uncondModel: artifacts['uncondModelPath']
+            }),
+            ...(artifacts?.['esrganModelPath'] && { esrgan: artifacts['esrganModelPath'] })
         };
         // `mode` is consumed by this plugin to select the model class above; the
         // stable-diffusion.cpp native config does not understand it. Strip it
@@ -174,13 +252,13 @@ export const diffusionPlugin = definePlugin({
         const { upscaler, mode, ...rest } = config;
         const addonConfig = {
             ...rest,
-            ...flattenUpscalerKeys(upscaler),
+            ...flattenUpscalerKeys(upscaler)
         };
         const model = new ImgStableDiffusion({
             files,
             config: addonConfig,
             logger,
-            opts: { stats: true },
+            opts: { stats: true }
         });
         return { model };
     },
@@ -191,15 +269,15 @@ export const diffusionPlugin = definePlugin({
             streaming: true,
             // sdcpp diffusion exposes a model-wide hard cancel — compute
             // is interrupted on the currently-running generation.
-            cancel: { scope: "model", hard: true },
-            handler: diffusion,
+            cancel: { scope: 'model', hard: true },
+            handler: diffusion
         }),
         videoStream: defineHandler({
             requestSchema: videoRequestSchema,
             responseSchema: videoStreamResponseSchema,
             streaming: true,
-            cancel: { scope: "model", hard: true },
-            handler: video,
+            cancel: { scope: 'model', hard: true },
+            handler: video
         }),
         upscaleStream: defineHandler({
             requestSchema: upscaleRequestSchema,
@@ -207,12 +285,12 @@ export const diffusionPlugin = definePlugin({
             streaming: true,
             // sdcpp upscale path has no cancel surface today — SDK falls
             // back to soft-cancel.
-            cancel: { scope: "none" },
-            handler: upscale,
-        }),
+            cancel: { scope: 'none' },
+            handler: upscale
+        })
     },
     logging: {
         module: addonLogging,
-        namespace: ModelType.sdcppGeneration,
-    },
+        namespace: ModelType.sdcppGeneration
+    }
 });

package/dist/server/bare/plugins/tts-ggml/ops/text-to-speech-stream.d.ts

@@ -1,5 +1,5 @@
-import { type TextToSpeechStreamRequest, type TtsStats } from "../../../../../schemas/index";
-import { type TtsOpYield } from "../../../utils/tts-stats";
+import { type TextToSpeechStreamRequest, type TtsStats } from '../../../../../schemas/index';
+import { type TtsOpYield } from '../../../utils/tts-stats';
 export declare function textToSpeechStream(params: TextToSpeechStreamRequest, inputStream: AsyncIterable<Buffer>): AsyncGenerator<TtsOpYield, {
     modelExecutionMs: number;
     stats?: TtsStats;

package/dist/server/bare/plugins/tts-ggml/ops/text-to-speech-stream.js

@@ -1,14 +1,14 @@
-import { getModel } from "../../../registry/model-registry.js";
-import { textToSpeechStreamRequestSchema, } from "../../../../../schemas/index.js";
-import { nowMs } from "../../../../../profiling/index.js";
-import { buildStreamResult, hasDefinedValues } from "../../../../../profiling/model-execution.js";
-import { TextToSpeechStreamFailedError } from "../../../../../utils/errors-server.js";
-import { collectTtsStats, } from "../../../utils/tts-stats.js";
+import { getModel } from '../../../registry/model-registry.js';
+import { textToSpeechStreamRequestSchema } from '../../../../../schemas/index.js';
+import { nowMs } from '../../../../../profiling/index.js';
+import { buildStreamResult, hasDefinedValues } from '../../../../../profiling/model-execution.js';
+import { TextToSpeechStreamFailedError } from '../../../../../utils/errors-server.js';
+import { collectTtsStats } from '../../../utils/tts-stats.js';
 function hasRunStreaming(model) {
-    return (typeof model === "object" &&
+    return (typeof model === 'object' &&
         model !== null &&
-        "runStreaming" in model &&
-        typeof model.runStreaming === "function");
+        'runStreaming' in model &&
+        typeof model.runStreaming === 'function');
 }
 function findLastCompleteUtf8End(buf) {
     const len = buf.length;
@@ -38,18 +38,16 @@ async function* buffersToUtf8Fragments(inputStream) {
         const combined = pending.length === 0 ? buf : Buffer.concat([pending, buf]);
         const completeEnd = findLastCompleteUtf8End(combined);
         if (completeEnd > 0) {
-            const s = combined.subarray(0, completeEnd).toString("utf8");
+            const s = combined.subarray(0, completeEnd).toString('utf8');
             if (s.length > 0) {
                 yield s;
             }
         }
         pending =
-            completeEnd < combined.length
-                ? Buffer.from(combined.subarray(completeEnd))
-                : Buffer.alloc(0);
+            completeEnd < combined.length ? Buffer.from(combined.subarray(completeEnd)) : Buffer.alloc(0);
     }
     if (pending.length > 0) {
-        const s = pending.toString("utf8");
+        const s = pending.toString('utf8');
         if (s.length > 0) {
             yield s;
         }
@@ -58,16 +56,16 @@ async function* buffersToUtf8Fragments(inputStream) {
 function buildRunStreamingOptions(request) {
     const o = {};
     if (request.accumulateSentences !== undefined) {
-        o["accumulateSentences"] = request.accumulateSentences;
+        o['accumulateSentences'] = request.accumulateSentences;
     }
     if (request.sentenceDelimiterPreset !== undefined) {
-        o["sentenceDelimiterPreset"] = request.sentenceDelimiterPreset;
+        o['sentenceDelimiterPreset'] = request.sentenceDelimiterPreset;
     }
     if (request.maxBufferScalars !== undefined) {
-        o["maxBufferScalars"] = request.maxBufferScalars;
+        o['maxBufferScalars'] = request.maxBufferScalars;
     }
     if (request.flushAfterMs !== undefined) {
-        o["flushAfterMs"] = request.flushAfterMs;
+        o['flushAfterMs'] = request.flushAfterMs;
     }
     return o;
 }
@@ -76,7 +74,7 @@ export async function* textToSpeechStream(params, inputStream) {
     const model = getModel(request.modelId);
     const modelStart = nowMs();
     if (!hasRunStreaming(model)) {
-        throw new TextToSpeechStreamFailedError("textToSpeechStream requires a TTS model with runStreaming");
+        throw new TextToSpeechStreamFailedError('textToSpeechStream requires a TTS model with runStreaming');
     }
     const textSource = buffersToUtf8Fragments(inputStream);
     const streamOpts = buildRunStreamingOptions(request);
@@ -92,9 +90,9 @@ export async function* textToSpeechStream(params, inputStream) {
         yield {
             buffer: buf,
             ...(data.chunkIndex !== undefined ? { chunkIndex: data.chunkIndex } : {}),
-            ...(typeof data.sentenceChunk === "string" && data.sentenceChunk.length > 0
+            ...(typeof data.sentenceChunk === 'string' && data.sentenceChunk.length > 0
                 ? { sentenceChunk: data.sentenceChunk }
-                : {}),
+                : {})
         };
     }
     const modelExecutionMs = nowMs() - modelStart;

package/dist/server/bare/plugins/tts-ggml/ops/text-to-speech.d.ts

@@ -1,5 +1,5 @@
-import { type TtsRequest, type TtsStats } from "../../../../../schemas/index";
-import { type TtsOpYield } from "../../../utils/tts-stats";
+import { type TtsRequest, type TtsStats } from '../../../../../schemas/index';
+import { type TtsOpYield } from '../../../utils/tts-stats';
 export declare function textToSpeech(params: TtsRequest): AsyncGenerator<TtsOpYield, {
     modelExecutionMs: number;
     stats?: TtsStats;

package/dist/server/bare/plugins/tts-ggml/ops/text-to-speech.js

@@ -1,31 +1,29 @@
-import { getModel } from "../../../registry/model-registry.js";
-import { ttsRequestSchema, } from "../../../../../schemas/index.js";
-import { nowMs } from "../../../../../profiling/index.js";
-import { buildStreamResult, hasDefinedValues } from "../../../../../profiling/model-execution.js";
-import { TextToSpeechFailedError } from "../../../../../utils/errors-server.js";
-import { collectTtsStats, } from "../../../utils/tts-stats.js";
+import { getModel } from '../../../registry/model-registry.js';
+import { ttsRequestSchema } from '../../../../../schemas/index.js';
+import { nowMs } from '../../../../../profiling/index.js';
+import { buildStreamResult, hasDefinedValues } from '../../../../../profiling/model-execution.js';
+import { TextToSpeechFailedError } from '../../../../../utils/errors-server.js';
+import { collectTtsStats } from '../../../utils/tts-stats.js';
 function hasRunStream(model) {
-    return (typeof model === "object" &&
+    return (typeof model === 'object' &&
         model !== null &&
-        "runStream" in model &&
-        typeof model.runStream === "function");
+        'runStream' in model &&
+        typeof model.runStream === 'function');
 }
 export async function* textToSpeech(params) {
-    const { modelId, inputType, text, stream, sentenceStream, sentenceStreamLocale, sentenceStreamMaxChunkScalars, } = ttsRequestSchema.parse(params);
+    const { modelId, inputType, text, stream, sentenceStream, sentenceStreamLocale, sentenceStreamMaxChunkScalars } = ttsRequestSchema.parse(params);
     const model = getModel(modelId);
     const modelStart = nowMs();
     if (sentenceStream) {
         if (!hasRunStream(model)) {
-            throw new TextToSpeechFailedError("sentenceStream requires a TTS model with runStream");
+            throw new TextToSpeechFailedError('sentenceStream requires a TTS model with runStream');
         }
         const streamOpts = sentenceStreamLocale !== undefined || sentenceStreamMaxChunkScalars !== undefined
             ? {
-                ...(sentenceStreamLocale !== undefined
-                    ? { locale: sentenceStreamLocale }
-                    : {}),
+                ...(sentenceStreamLocale !== undefined ? { locale: sentenceStreamLocale } : {}),
                 ...(sentenceStreamMaxChunkScalars !== undefined
                     ? { maxChunkScalars: sentenceStreamMaxChunkScalars }
-                    : {}),
+                    : {})
             }
             : undefined;
         const response = await model.runStream(text, streamOpts);
@@ -50,9 +48,9 @@ export async function* textToSpeech(params) {
             yield {
                 buffer: buf,
                 ...(data.chunkIndex !== undefined ? { chunkIndex: data.chunkIndex } : {}),
-                ...(typeof data.sentenceChunk === "string" && data.sentenceChunk.length > 0
+                ...(typeof data.sentenceChunk === 'string' && data.sentenceChunk.length > 0
                     ? { sentenceChunk: data.sentenceChunk }
-                    : {}),
+                    : {})
             };
         }
         const modelExecutionMs = nowMs() - modelStart;
@@ -62,7 +60,7 @@ export async function* textToSpeech(params) {
     const response = (await model.run({
         input: text,
         inputType,
-        ...(stream ? { streamOutput: true } : {}),
+        ...(stream ? { streamOutput: true } : {})
     }));
     if (!stream) {
         let completeBuffer = [];
@@ -70,14 +68,7 @@ export async function* textToSpeech(params) {
             completeBuffer = completeBuffer.concat(Array.from(data.outputArray));
         }
         const modelExecutionMs = nowMs() - modelStart;
-        const stats = {
-            ...(response.stats?.audioDurationMs !== undefined && {
-                audioDuration: response.stats.audioDurationMs,
-            }),
-            ...(response.stats?.totalSamples !== undefined && {
-                totalSamples: response.stats.totalSamples,
-            }),
-        };
+        const stats = collectTtsStats(response);
         yield { buffer: completeBuffer };
         return buildStreamResult(modelExecutionMs, hasDefinedValues(stats) ? stats : undefined);
     }
@@ -85,13 +76,6 @@ export async function* textToSpeech(params) {
         yield { buffer: Array.from(data.outputArray) };
     }
     const modelExecutionMs = nowMs() - modelStart;
-    const stats = {
-        ...(response.stats?.audioDurationMs !== undefined && {
-            audioDuration: response.stats.audioDurationMs,
-        }),
-        ...(response.stats?.totalSamples !== undefined && {
-            totalSamples: response.stats.totalSamples,
-        }),
-    };
+    const stats = collectTtsStats(response);
     return buildStreamResult(modelExecutionMs, hasDefinedValues(stats) ? stats : undefined);
 }

package/dist/server/bare/plugins/tts-ggml/plugin.d.ts

@@ -1,4 +1,4 @@
-import { type CreateModelParams, type PluginModelResult, type ResolveContext, type ResolveResult } from "../../../../schemas/index";
+import { type CreateModelParams, type PluginModelResult, type ResolveContext, type ResolveResult } from '../../../../schemas/index';
 export declare const ttsPlugin: {
     modelType: "tts-ggml";
     displayName: string;
@@ -10,12 +10,13 @@ export declare const ttsPlugin: {
     }, import("zod/v4/core").$strict>], "ttsEngine">;
     resolveConfig(cfg: Record<string, unknown>, ctx: ResolveContext): Promise<ResolveResult<{
         ttsEngine: "chatterbox";
-        language: "en" | "ar" | "de" | "es" | "fi" | "fr" | "it" | "ko" | "nl" | "pl" | "pt" | "ru" | "zh" | "da" | "el" | "he" | "hi" | "ms" | "no" | "sv" | "tr" | "sw";
+        language: "en" | "ar" | "de" | "es" | "fi" | "fr" | "it" | "ja" | "ko" | "nl" | "pl" | "pt" | "ru" | "zh" | "da" | "el" | "he" | "hi" | "ms" | "no" | "sv" | "tr" | "sw";
         voice?: string | undefined;
         useGPU?: boolean | undefined;
         streamChunkTokens?: number | undefined;
         streamFirstChunkTokens?: number | undefined;
         cfmSteps?: number | undefined;
+        cfgRate?: number | undefined;
         threads?: number | undefined;
         nGpuLayers?: number | undefined;
         seed?: number | undefined;
@@ -26,6 +27,8 @@ export declare const ttsPlugin: {
         ttsSpeed?: number | undefined;
         ttsNumInferenceSteps?: number | undefined;
         useGPU?: boolean | undefined;
+        outputSampleRate?: number | undefined;
+        vulkanCacheDir?: string | undefined;
     }, string>>;
     createModel(params: CreateModelParams): PluginModelResult;
     handlers: {
@@ -45,6 +48,8 @@ export declare const ttsPlugin: {
             stats: import("zod").ZodOptional<import("zod").ZodObject<{
                 audioDuration: import("zod").ZodOptional<import("zod").ZodNumber>;
                 totalSamples: import("zod").ZodOptional<import("zod").ZodNumber>;
+                enhancerBackendDevice: import("zod").ZodOptional<import("zod").ZodNumber>;
+                enhancerBackendId: import("zod").ZodOptional<import("zod").ZodNumber>;
             }, import("zod/v4/core").$strip>>;
             chunkIndex: import("zod").ZodOptional<import("zod").ZodNumber>;
             sentenceChunk: import("zod").ZodOptional<import("zod").ZodString>;
@@ -68,6 +73,8 @@ export declare const ttsPlugin: {
             stats: import("zod").ZodOptional<import("zod").ZodObject<{
                 audioDuration: import("zod").ZodOptional<import("zod").ZodNumber>;
                 totalSamples: import("zod").ZodOptional<import("zod").ZodNumber>;
+                enhancerBackendDevice: import("zod").ZodOptional<import("zod").ZodNumber>;
+                enhancerBackendId: import("zod").ZodOptional<import("zod").ZodNumber>;
             }, import("zod/v4/core").$strip>>;
             chunkIndex: import("zod").ZodOptional<import("zod").ZodNumber>;
             sentenceChunk: import("zod").ZodOptional<import("zod").ZodString>;