@qvac/sdk 0.18.2 → 0.19.1

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

@@ -1,310 +0,0 @@
-import ImgStableDiffusion, { EsrganUpscaler, VideoStableDiffusion } from '@qvac/diffusion-cpp';
-import addonLogging from '@qvac/diffusion-cpp/addonLogging';
-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 '../../../../server/bare/registry/runtime-context-registry.js';
-import { stripMultiGpuKeys } from '../../../../server/utils/multi-gpu-mobile.js';
-import { diffusion } from './ops/diffusion.js';
-import { markLtxVideoModel, markMoeCapableVideoModel, 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
-// drift if `@qvac/diffusion-cpp` ever adds or renames an `upscaler_*` key.
-function flattenUpscalerKeys(upscaler) {
-    if (!upscaler)
-        return {};
-    return {
-        ...(upscaler.tile_size !== undefined && {
-            upscaler_tile_size: upscaler.tile_size
-        }),
-        ...(upscaler.direct !== undefined && {
-            upscaler_direct: upscaler.direct
-        }),
-        ...(upscaler.offload_params_to_cpu !== undefined && {
-            upscaler_offload_params_to_cpu: upscaler.offload_params_to_cpu
-        }),
-        ...(upscaler.threads !== undefined && {
-            upscaler_threads: upscaler.threads
-        })
-    };
-}
-// `mode: "upscale"` builds an EsrganUpscaler directly (not via SdCtx), so the
-// top-level `device` field has to be forwarded explicitly — it is not part of
-// the `upscaler.*` block.
-function toEsrganAddonConfig(config) {
-    return {
-        ...flattenUpscalerKeys(config.upscaler),
-        ...(config.device !== undefined && { device: config.device }),
-        ...(config.verbosity !== undefined && { verbosity: config.verbosity })
-    };
-}
-/**
- * Stable-diffusion.cpp plugin for image diffusion, upscaling, and Wan video.
- *
- * Video mode is supported on React Native, but the SDK-published Wan model
- * set is too large to load on typical mobile devices. Mobile apps should
- * pass a `delegate` to `loadModel(...)` to run video generation on a
- * desktop peer instead of loading the model on-device.
- */
-export const diffusionPlugin = definePlugin({
-    modelType: ModelType.sdcppGeneration,
-    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.');
-        }
-        // A high-noise expert only has somewhere to go in the Wan 2.2 A14B video
-        // layout: every other mode builds a model with no second-expert slot, and
-        // embeddingsConnectorsModelSrc selects LTX-2 instead. Check it ahead of the
-        // upscale early-return so a wrong layout fails loudly rather than
-        // downloading a multi-gigabyte expert and dropping it in createModel.
-        const isWan22MoeLayout = cfg.mode === 'video' && !cfg.embeddingsConnectorsModelSrc;
-        if (cfg.highNoiseDiffusionModelSrc && !isWan22MoeLayout) {
-            throw new ModelLoadFailedError('modelConfig.highNoiseDiffusionModelSrc selects the Wan 2.2 A14B ' +
-                "mixture-of-experts video layout. It requires mode: 'video' and " +
-                'cannot be combined with modelConfig.embeddingsConnectorsModelSrc ' +
-                '(which selects the LTX-2 layout).');
-        }
-        // 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') {
-            return { config: 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 { model_src: esrganModelSrc, ...upscalerRuntime } = effectiveUpscaler ?? {};
-        const runtimeConfig = {
-            ...rest,
-            ...(effectiveUpscaler && { upscaler: upscalerRuntime })
-        };
-        const sources = {
-            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, uncondModelPath, audioVaeModelPath, embeddingsConnectorsModelPath, esrganModelPath] = await Promise.all([
-            clipLModelSrc ? resolve(clipLModelSrc) : undefined,
-            clipGModelSrc ? resolve(clipGModelSrc) : undefined,
-            clipVisionModelSrc ? resolve(clipVisionModelSrc) : undefined,
-            t5XxlModelSrc ? resolve(t5XxlModelSrc) : undefined,
-            llmModelSrc ? resolve(llmModelSrc) : undefined,
-            vaeModelSrc ? resolve(vaeModelSrc) : undefined,
-            highNoiseDiffusionModelSrc ? resolve(highNoiseDiffusionModelSrc) : undefined,
-            uncondModelSrc ? resolve(uncondModelSrc) : undefined,
-            audioVaeModelSrc ? resolve(audioVaeModelSrc) : undefined,
-            embeddingsConnectorsModelSrc ? resolve(embeddingsConnectorsModelSrc) : undefined,
-            esrganModelSrc ? resolve(esrganModelSrc) : undefined
-        ]);
-        return {
-            config: runtimeConfig,
-            artifacts: {
-                ...(clipLModelPath && { clipLModelPath }),
-                ...(clipGModelPath && { clipGModelPath }),
-                ...(clipVisionModelPath && { clipVisionModelPath }),
-                ...(t5XxlModelPath && { t5XxlModelPath }),
-                ...(llmModelPath && { llmModelPath }),
-                ...(vaeModelPath && { vaeModelPath }),
-                ...(highNoiseDiffusionModelPath && { highNoiseDiffusionModelPath }),
-                ...(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' &&
-            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 ' +
-                "upscaler block, or switch to modelConfig.mode = 'upscale' to load " +
-                'a standalone upscaler.');
-        }
-        const logger = createStreamLogger(modelId, ModelType.sdcppGeneration);
-        registerAddonLogger(modelId, ModelType.sdcppGeneration, logger);
-        if (config.mode === 'upscale') {
-            const model = new EsrganUpscaler({
-                files: { esrgan: modelPath },
-                config: toEsrganAddonConfig(config),
-                logger,
-                opts: { stats: true }
-            });
-            return { model };
-        }
-        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'] })
-                };
-            }
-            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'] })
-                };
-            }
-            /* eslint-disable @typescript-eslint/no-unused-vars */
-            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 }
-            });
-            if (embeddingsConnectorsModelPath)
-                markLtxVideoModel(model);
-            if (files.highNoiseDiffusionModel)
-                markMoeCapableVideoModel(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?.['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
-        // before forwarding `rest` to the addon.
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { upscaler, mode, ...rest } = config;
-        const addonConfig = {
-            ...rest,
-            ...flattenUpscalerKeys(upscaler)
-        };
-        const model = new ImgStableDiffusion({
-            files,
-            config: addonConfig,
-            logger,
-            opts: { stats: true }
-        });
-        return { model };
-    },
-    handlers: {
-        diffusionStream: defineHandler({
-            requestSchema: diffusionRequestSchema,
-            responseSchema: diffusionStreamResponseSchema,
-            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
-        }),
-        videoStream: defineHandler({
-            requestSchema: videoRequestSchema,
-            responseSchema: videoStreamResponseSchema,
-            streaming: true,
-            cancel: { scope: 'model', hard: true },
-            handler: video
-        }),
-        upscaleStream: defineHandler({
-            requestSchema: upscaleRequestSchema,
-            responseSchema: upscaleStreamResponseSchema,
-            streaming: true,
-            // sdcpp upscale path has no cancel surface today — SDK falls
-            // back to soft-cancel.
-            cancel: { scope: 'none' },
-            handler: upscale
-        })
-    },
-    logging: {
-        module: addonLogging,
-        namespace: ModelType.sdcppGeneration
-    }
-});

package/dist/server/bare/plugins/tts-ggml/ops/parler-options.d.ts

@@ -1,7 +0,0 @@
-import type { TextToSpeechStreamRequest, TtsRequest } from '../../../../../schemas/index.js';
-export type ParlerJobOptions = Pick<TtsRequest, 'description' | 'voiceDescription' | 'voice' | 'emotion' | 'pitch' | 'pace' | 'expressivity' | 'noise' | 'reverb' | 'quality'>;
-type ParlerJobOptionsRequest = TtsRequest | TextToSpeechStreamRequest;
-export declare function getParlerJobOptions(request: ParlerJobOptionsRequest): ParlerJobOptions;
-export declare function assertParlerJobOptionsSupported(model: unknown, options: ParlerJobOptions, handlerName: 'textToSpeech' | 'textToSpeechStream'): void;
-export {};
-//# sourceMappingURL=parler-options.d.ts.map

package/dist/server/bare/plugins/tts-ggml/ops/parler-options.js

@@ -1,50 +0,0 @@
-import { PluginRequestValidationFailedError } from '../../../../../utils/errors-server.js';
-function hasEngineType(model) {
-    return (typeof model === 'object' &&
-        model !== null &&
-        'getEngineType' in model &&
-        typeof model.getEngineType === 'function');
-}
-export function getParlerJobOptions(request) {
-    return {
-        ...(request.description !== undefined ? { description: request.description } : {}),
-        ...(request.voiceDescription !== undefined
-            ? { voiceDescription: request.voiceDescription }
-            : {}),
-        ...(request.voice !== undefined ? { voice: request.voice } : {}),
-        ...(request.emotion !== undefined ? { emotion: request.emotion } : {}),
-        ...(request.pitch !== undefined ? { pitch: request.pitch } : {}),
-        ...(request.pace !== undefined ? { pace: request.pace } : {}),
-        ...(request.expressivity !== undefined ? { expressivity: request.expressivity } : {}),
-        ...(request.noise !== undefined ? { noise: request.noise } : {}),
-        ...(request.reverb !== undefined ? { reverb: request.reverb } : {}),
-        ...(request.quality !== undefined ? { quality: request.quality } : {})
-    };
-}
-// Per-call conditioning keys shared by the engines that support them.
-// CosyVoice3 accepts the cross-engine emotion/pace pair; everything else in
-// the description/template surface remains Parler-only.
-const CROSS_ENGINE_CONDITIONING_KEYS = ['emotion', 'pace'];
-export function assertParlerJobOptionsSupported(model, options, handlerName) {
-    const setKeys = Object.keys(options);
-    if (setKeys.length === 0)
-        return;
-    const engine = hasEngineType(model) ? model.getEngineType() : undefined;
-    if (engine === 'parler')
-        return;
-    if (engine === 'cosyvoice3') {
-        const parlerOnlyKeys = setKeys.filter((key) => !CROSS_ENGINE_CONDITIONING_KEYS.includes(key));
-        if (parlerOnlyKeys.length > 0) {
-            throw new PluginRequestValidationFailedError(handlerName, `${parlerOnlyKeys.join(', ')} ${parlerOnlyKeys.length === 1 ? 'is' : 'are'} only supported by Parler TTS models; CosyVoice3 supports emotion and pace`);
-        }
-        // CosyVoice3 is trained on one instruction per synthesis; a request that
-        // engages both channels always conflicts regardless of the loaded config.
-        if (options.emotion !== undefined &&
-            options.pace !== undefined &&
-            options.pace !== 'moderate') {
-            throw new PluginRequestValidationFailedError(handlerName, 'CosyVoice3 accepts one conditioning control per synthesis; set either emotion or a non-moderate pace, not both');
-        }
-        return;
-    }
-    throw new PluginRequestValidationFailedError(handlerName, 'description, voiceDescription, voice, emotion, pitch, pace, expressivity, noise, reverb, and quality are only supported by Parler TTS and CosyVoice3 models (CosyVoice3: emotion and pace only)');
-}

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

@@ -1,7 +0,0 @@
-import { type TextToSpeechStreamRequest, type TtsStats } from '../../../../../schemas/index.js';
-import { type TtsOpYield } from '../../../../../server/bare/utils/tts-stats.js';
-export declare function textToSpeechStream(params: TextToSpeechStreamRequest, inputStream: AsyncIterable<Buffer>): AsyncGenerator<TtsOpYield, {
-    modelExecutionMs: number;
-    stats?: TtsStats;
-}, unknown>;
-//# sourceMappingURL=text-to-speech-stream.d.ts.map

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

@@ -1,104 +0,0 @@
-import { getModel } from '../../../../../server/bare/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 '../../../../../server/bare/utils/tts-stats.js';
-import { assertParlerJobOptionsSupported, getParlerJobOptions } from '../../../../../server/bare/plugins/tts-ggml/ops/parler-options.js';
-function hasRunStreaming(model) {
-    return (typeof model === 'object' &&
-        model !== null &&
-        'runStreaming' in model &&
-        typeof model.runStreaming === 'function');
-}
-function findLastCompleteUtf8End(buf) {
-    const len = buf.length;
-    for (let i = len - 1; i >= 0 && i >= len - 3; i--) {
-        const b = buf[i];
-        if ((b & 0x80) === 0) {
-            return i + 1;
-        }
-        if ((b & 0xc0) === 0xc0) {
-            let expected;
-            if ((b & 0xe0) === 0xc0)
-                expected = 2;
-            else if ((b & 0xf0) === 0xe0)
-                expected = 3;
-            else if ((b & 0xf8) === 0xf0)
-                expected = 4;
-            else
-                return len;
-            return i + expected <= len ? len : i;
-        }
-    }
-    return len;
-}
-async function* buffersToUtf8Fragments(inputStream) {
-    let pending = Buffer.alloc(0);
-    for await (const buf of 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');
-            if (s.length > 0) {
-                yield s;
-            }
-        }
-        pending =
-            completeEnd < combined.length ? Buffer.from(combined.subarray(completeEnd)) : Buffer.alloc(0);
-    }
-    if (pending.length > 0) {
-        const s = pending.toString('utf8');
-        if (s.length > 0) {
-            yield s;
-        }
-    }
-}
-function buildRunStreamingOptions(request, parlerJobOptions) {
-    const o = {};
-    if (request.accumulateSentences !== undefined) {
-        o['accumulateSentences'] = request.accumulateSentences;
-    }
-    if (request.sentenceDelimiterPreset !== undefined) {
-        o['sentenceDelimiterPreset'] = request.sentenceDelimiterPreset;
-    }
-    if (request.maxBufferScalars !== undefined) {
-        o['maxBufferScalars'] = request.maxBufferScalars;
-    }
-    if (request.flushAfterMs !== undefined) {
-        o['flushAfterMs'] = request.flushAfterMs;
-    }
-    return { ...o, ...parlerJobOptions };
-}
-export async function* textToSpeechStream(params, inputStream) {
-    const request = textToSpeechStreamRequestSchema.parse(params);
-    const model = getModel(request.modelId);
-    const parlerJobOptions = getParlerJobOptions(request);
-    assertParlerJobOptionsSupported(model, parlerJobOptions, 'textToSpeechStream');
-    const modelStart = nowMs();
-    if (!hasRunStreaming(model)) {
-        throw new TextToSpeechStreamFailedError('textToSpeechStream requires a TTS model with runStreaming');
-    }
-    const textSource = buffersToUtf8Fragments(inputStream);
-    const streamOpts = buildRunStreamingOptions(request, parlerJobOptions);
-    const response = await model.runStreaming(textSource, Object.keys(streamOpts).length > 0 ? streamOpts : undefined);
-    for await (const data of response.iterate()) {
-        if (data.outputArray == null) {
-            continue;
-        }
-        const buf = Array.from(data.outputArray);
-        if (buf.length === 0) {
-            continue;
-        }
-        yield {
-            buffer: buf,
-            ...(data.chunkIndex !== undefined ? { chunkIndex: data.chunkIndex } : {}),
-            ...(typeof data.sentenceChunk === 'string' && data.sentenceChunk.length > 0
-                ? { sentenceChunk: data.sentenceChunk }
-                : {})
-        };
-    }
-    const modelExecutionMs = nowMs() - modelStart;
-    const stats = collectTtsStats(response);
-    return buildStreamResult(modelExecutionMs, hasDefinedValues(stats) ? stats : undefined);
-}

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

@@ -1,7 +0,0 @@
-import { type TtsRequest, type TtsStats } from '../../../../../schemas/index.js';
-import { type TtsOpYield } from '../../../../../server/bare/utils/tts-stats.js';
-export declare function textToSpeech(params: TtsRequest): AsyncGenerator<TtsOpYield, {
-    modelExecutionMs: number;
-    stats?: TtsStats;
-}>;
-//# sourceMappingURL=text-to-speech.d.ts.map

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

@@ -1,89 +0,0 @@
-import { getModel } from '../../../../../server/bare/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 '../../../../../server/bare/utils/tts-stats.js';
-import { assertParlerJobOptionsSupported, getParlerJobOptions } from '../../../../../server/bare/plugins/tts-ggml/ops/parler-options.js';
-function hasRunStream(model) {
-    return (typeof model === 'object' &&
-        model !== null &&
-        'runStream' in model &&
-        typeof model.runStream === 'function');
-}
-export async function* textToSpeech(params) {
-    const request = ttsRequestSchema.parse(params);
-    const { modelId, inputType, text, stream, sentenceStream, sentenceStreamLocale, sentenceStreamMaxChunkScalars } = request;
-    const parlerJobOptions = getParlerJobOptions(request);
-    const model = getModel(modelId);
-    assertParlerJobOptionsSupported(model, parlerJobOptions, 'textToSpeech');
-    const modelStart = nowMs();
-    if (sentenceStream) {
-        if (!hasRunStream(model)) {
-            throw new TextToSpeechFailedError('sentenceStream requires a TTS model with runStream');
-        }
-        const streamOpts = sentenceStreamLocale !== undefined ||
-            sentenceStreamMaxChunkScalars !== undefined ||
-            Object.keys(parlerJobOptions).length > 0
-            ? {
-                ...(sentenceStreamLocale !== undefined ? { locale: sentenceStreamLocale } : {}),
-                ...(sentenceStreamMaxChunkScalars !== undefined
-                    ? { maxChunkScalars: sentenceStreamMaxChunkScalars }
-                    : {}),
-                ...parlerJobOptions
-            }
-            : undefined;
-        const response = await model.runStream(text, streamOpts);
-        if (!stream) {
-            let completeBuffer = [];
-            for await (const data of response.iterate()) {
-                if (data.outputArray != null) {
-                    completeBuffer = completeBuffer.concat(Array.from(data.outputArray));
-                }
-            }
-            const modelExecutionMs = nowMs() - modelStart;
-            const stats = collectTtsStats(response);
-            yield { buffer: completeBuffer };
-            return buildStreamResult(modelExecutionMs, hasDefinedValues(stats) ? stats : undefined);
-        }
-        for await (const data of response.iterate()) {
-            if (data.outputArray == null)
-                continue;
-            const buf = Array.from(data.outputArray);
-            if (buf.length === 0)
-                continue;
-            yield {
-                buffer: buf,
-                ...(data.chunkIndex !== undefined ? { chunkIndex: data.chunkIndex } : {}),
-                ...(typeof data.sentenceChunk === 'string' && data.sentenceChunk.length > 0
-                    ? { sentenceChunk: data.sentenceChunk }
-                    : {})
-            };
-        }
-        const modelExecutionMs = nowMs() - modelStart;
-        const stats = collectTtsStats(response);
-        return buildStreamResult(modelExecutionMs, hasDefinedValues(stats) ? stats : undefined);
-    }
-    const response = (await model.run({
-        input: text,
-        inputType,
-        ...(stream ? { streamOutput: true } : {}),
-        ...parlerJobOptions
-    }));
-    if (!stream) {
-        let completeBuffer = [];
-        for await (const data of response.iterate()) {
-            completeBuffer = completeBuffer.concat(Array.from(data.outputArray));
-        }
-        const modelExecutionMs = nowMs() - modelStart;
-        const stats = collectTtsStats(response);
-        yield { buffer: completeBuffer };
-        return buildStreamResult(modelExecutionMs, hasDefinedValues(stats) ? stats : undefined);
-    }
-    for await (const data of response.iterate()) {
-        yield { buffer: Array.from(data.outputArray) };
-    }
-    const modelExecutionMs = nowMs() - modelStart;
-    const stats = collectTtsStats(response);
-    return buildStreamResult(modelExecutionMs, hasDefinedValues(stats) ? stats : undefined);
-}