@qvac/sdk 0.18.2 → 0.19.0

package/dist/server/bare/plugins/audiogen-ggml/ops/audio-gen-stream.js

@@ -1,213 +0,0 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { AudioGen } from '@qvac/audiogen-ggml';
-import { audioGenStatsSchema } from '../../../../../schemas/audio-gen.js';
-import { getServerLogger } from '../../../../../logging/index.js';
-import { resolveAudioGenPcm } from '../../../../../server/bare/plugins/audiogen-ggml/ops/audio-gen-input.js';
-import { getModel } from '../../../../../server/bare/registry/model-registry.js';
-import { getRequestRegistry, withRequestContext } from '../../../../../server/bare/runtime/index.js';
-import { generateServerRequestId } from '../../../../../server/bare/runtime/request-id.js';
-import { ModelOperationNotSupportedError } from '../../../../../utils/errors-server.js';
-export async function* audioGenStream(request) {
-    const env_1 = { stack: [], error: void 0, hasError: false };
-    try {
-        const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
-            requestId: request.requestId ?? generateServerRequestId(),
-            kind: 'audiogen',
-            modelId: request.modelId
-        }), true);
-        const logger = withRequestContext(getServerLogger(), ctx);
-        const candidate = getModel(request.modelId);
-        if (!(candidate instanceof AudioGen)) {
-            throw new ModelOperationNotSupportedError(request.modelId, 'audiogen-ggml', 'audioGenStream', [], []);
-        }
-        const model = candidate;
-        // A queued request can resume from begin() already aborted. It never owned
-        // the model slot, so calling the model-scoped cancel here would interrupt
-        // the earlier same-model generation that still owns it.
-        if (Boolean(ctx.signal.aborted)) {
-            yield {
-                type: 'audioGenStream',
-                done: true,
-                stopReason: 'cancelled'
-            };
-            return;
-        }
-        let cancelPromise;
-        const onAbort = () => {
-            cancelPromise ??= model.cancel().catch((error) => {
-                logger.warn(`[cancel] model.cancel() rejected during abort for modelId=${request.modelId}: ${error instanceof Error ? error.message : String(error)}`);
-            });
-        };
-        ctx.signal.addEventListener('abort', onAbort, { once: true });
-        if (ctx.signal.aborted)
-            onAbort();
-        ctx.scope.defer(async () => {
-            ctx.signal.removeEventListener('abort', onAbort);
-            await cancelPromise;
-        });
-        let response;
-        try {
-            // Reference/source audio is decoded before the run is admitted so the
-            // model slot is never held by a request that fails on input decoding.
-            // Decoding can take real time, so the abort state is re-checked after it:
-            // an abort that fired mid-decode found no active native job to cancel, and
-            // starting the run afterwards would leave a ghost generation on the slot.
-            const { referenceAudio, sourceAudio } = ctx.signal.aborted
-                ? {}
-                : await resolveAudioInputs(request, logger);
-            if (!ctx.signal.aborted) {
-                response = await model.run(request.caption, {
-                    ...(request.lyrics !== undefined && { lyrics: request.lyrics }),
-                    ...(request.seed !== undefined && { seed: request.seed }),
-                    ...(request.vocalLanguage !== undefined && { vocalLanguage: request.vocalLanguage }),
-                    ...(request.bpm !== undefined && { bpm: request.bpm }),
-                    ...(request.keyscale !== undefined && { keyscale: request.keyscale }),
-                    ...(request.timesignature !== undefined && { timesignature: request.timesignature }),
-                    ...(request.duration !== undefined && { duration: request.duration }),
-                    ...(request.lmTemperature !== undefined && { lmTemperature: request.lmTemperature }),
-                    ...(request.lmTopP !== undefined && { lmTopP: request.lmTopP }),
-                    ...(request.lmTopK !== undefined && { lmTopK: request.lmTopK }),
-                    ...(request.lmCfgScale !== undefined && { lmCfgScale: request.lmCfgScale }),
-                    ...(request.lmPhase1 !== undefined && { lmPhase1: request.lmPhase1 }),
-                    ...(request.dcwEnabled !== undefined && { dcwEnabled: request.dcwEnabled }),
-                    ...(request.dcwScaler !== undefined && { dcwScaler: request.dcwScaler }),
-                    ...(request.dcwHighScaler !== undefined && { dcwHighScaler: request.dcwHighScaler }),
-                    ...(request.taskType !== undefined && { taskType: request.taskType }),
-                    ...(request.audioCoverStrength !== undefined && {
-                        audioCoverStrength: request.audioCoverStrength
-                    }),
-                    ...(request.coverNoiseStrength !== undefined && {
-                        coverNoiseStrength: request.coverNoiseStrength
-                    }),
-                    ...(referenceAudio && { referenceAudio }),
-                    ...(sourceAudio && { sourceAudio })
-                });
-                for await (const chunk of response.iterate()) {
-                    if (ctx.signal.aborted)
-                        break;
-                    if ('progress' in chunk) {
-                        yield {
-                            type: 'audioGenStream',
-                            progress: chunk.progress,
-                            done: false
-                        };
-                        continue;
-                    }
-                    const pcm = new Uint8Array(chunk.outputArray.buffer, chunk.outputArray.byteOffset, chunk.outputArray.byteLength);
-                    yield {
-                        type: 'audioGenStream',
-                        data: Buffer.from(pcm).toString('base64'),
-                        sampleRate: chunk.sampleRate,
-                        channels: chunk.channels,
-                        bitsPerSample: Int16Array.BYTES_PER_ELEMENT * 8,
-                        done: false
-                    };
-                }
-            }
-        }
-        catch (error) {
-            if (!ctx.signal.aborted)
-                throw error;
-        }
-        if (ctx.signal.aborted) {
-            yield {
-                type: 'audioGenStream',
-                done: true,
-                stopReason: 'cancelled'
-            };
-            return;
-        }
-        const stats = audioGenStatsSchema.parse(await response.await());
-        yield {
-            type: 'audioGenStream',
-            done: true,
-            stopReason: 'completed',
-            stats
-        };
-    }
-    catch (e_1) {
-        env_1.error = e_1;
-        env_1.hasError = true;
-    }
-    finally {
-        const result_1 = __disposeResources(env_1);
-        if (result_1)
-            await result_1;
-    }
-}
-/**
- * Decode both optional audio inputs concurrently. When both fail, the first
- * failure is thrown and the second is logged so neither diagnostic is lost.
- */
-async function resolveAudioInputs(request, logger) {
-    const [reference, source] = await Promise.allSettled([
-        request.referenceAudio
-            ? resolveAudioGenPcm(request.referenceAudio, 'referenceAudio')
-            : Promise.resolve(undefined),
-        request.sourceAudio
-            ? resolveAudioGenPcm(request.sourceAudio, 'sourceAudio')
-            : Promise.resolve(undefined)
-    ]);
-    const failures = [reference, source].filter((result) => result.status === 'rejected');
-    if (failures.length > 0) {
-        for (const extra of failures.slice(1)) {
-            logger.warn(`[audiogen] additional audio input failure for modelId=${request.modelId}: ${extra.reason instanceof Error ? extra.reason.message : String(extra.reason)}`);
-        }
-        throw failures[0].reason;
-    }
-    return {
-        referenceAudio: reference.status === 'fulfilled' ? reference.value : undefined,
-        sourceAudio: source.status === 'fulfilled' ? source.value : undefined
-    };
-}

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

@@ -1,241 +0,0 @@
-import { type CreateModelParams, type PluginModelResult } from '../../../../schemas/index.js';
-import { resolveAudioGenConfig } from '../../../../server/bare/plugins/audiogen-ggml/config.js';
-export declare const audioGenPlugin: {
-    modelType: "audiogen-ggml";
-    displayName: string;
-    addonPackage: "@qvac/audiogen-ggml";
-    loadConfigSchema: import("zod").ZodObject<{
-        useGPU: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        inferenceSteps: import("zod").ZodOptional<import("zod").ZodNumber>;
-        shift: import("zod").ZodOptional<import("zod").ZodNumber>;
-        nGpuLayers: import("zod").ZodOptional<import("zod").ZodNumber>;
-        threads: import("zod").ZodOptional<import("zod").ZodNumber>;
-        backendsDir: import("zod").ZodOptional<import("zod").ZodString>;
-        textEncModelSrc: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
-            src: import("zod").ZodString;
-            name: import("zod").ZodOptional<import("zod").ZodString>;
-            modelId: import("zod").ZodOptional<import("zod").ZodString>;
-            registryPath: import("zod").ZodOptional<import("zod").ZodString>;
-            registrySource: import("zod").ZodOptional<import("zod").ZodString>;
-            blobCoreKey: import("zod").ZodOptional<import("zod").ZodString>;
-            blobIndex: import("zod").ZodOptional<import("zod").ZodNumber>;
-            engine: import("zod").ZodOptional<import("zod").ZodString>;
-            expectedSize: import("zod").ZodOptional<import("zod").ZodNumber>;
-            sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
-            addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
-                embeddings: "embeddings";
-                diffusion: "diffusion";
-                audiogen: "audiogen";
-                tts: "tts";
-                ocr: "ocr";
-                vla: "vla";
-                "llamacpp-completion": "llamacpp-completion";
-                "whispercpp-transcription": "whispercpp-transcription";
-                "bci-whispercpp-transcription": "bci-whispercpp-transcription";
-                "llamacpp-embedding": "llamacpp-embedding";
-                "nmtcpp-translation": "nmtcpp-translation";
-                "onnx-tts": "onnx-tts";
-                "tts-ggml": "tts-ggml";
-                "parakeet-transcription": "parakeet-transcription";
-                "ggml-ocr": "ggml-ocr";
-                "sdcpp-generation": "sdcpp-generation";
-                "audiogen-ggml": "audiogen-ggml";
-                "ggml-vla": "ggml-vla";
-                "ggml-classification": "ggml-classification";
-                llm: "llm";
-                whisper: "whisper";
-                bci: "bci";
-                nmt: "nmt";
-                parakeet: "parakeet";
-                classification: "classification";
-            }>, import("zod").ZodLiteral<"vad">]>>;
-        }, import("zod/v4/core").$strip>]>;
-        lmModelSrc: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
-            src: import("zod").ZodString;
-            name: import("zod").ZodOptional<import("zod").ZodString>;
-            modelId: import("zod").ZodOptional<import("zod").ZodString>;
-            registryPath: import("zod").ZodOptional<import("zod").ZodString>;
-            registrySource: import("zod").ZodOptional<import("zod").ZodString>;
-            blobCoreKey: import("zod").ZodOptional<import("zod").ZodString>;
-            blobIndex: import("zod").ZodOptional<import("zod").ZodNumber>;
-            engine: import("zod").ZodOptional<import("zod").ZodString>;
-            expectedSize: import("zod").ZodOptional<import("zod").ZodNumber>;
-            sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
-            addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
-                embeddings: "embeddings";
-                diffusion: "diffusion";
-                audiogen: "audiogen";
-                tts: "tts";
-                ocr: "ocr";
-                vla: "vla";
-                "llamacpp-completion": "llamacpp-completion";
-                "whispercpp-transcription": "whispercpp-transcription";
-                "bci-whispercpp-transcription": "bci-whispercpp-transcription";
-                "llamacpp-embedding": "llamacpp-embedding";
-                "nmtcpp-translation": "nmtcpp-translation";
-                "onnx-tts": "onnx-tts";
-                "tts-ggml": "tts-ggml";
-                "parakeet-transcription": "parakeet-transcription";
-                "ggml-ocr": "ggml-ocr";
-                "sdcpp-generation": "sdcpp-generation";
-                "audiogen-ggml": "audiogen-ggml";
-                "ggml-vla": "ggml-vla";
-                "ggml-classification": "ggml-classification";
-                llm: "llm";
-                whisper: "whisper";
-                bci: "bci";
-                nmt: "nmt";
-                parakeet: "parakeet";
-                classification: "classification";
-            }>, import("zod").ZodLiteral<"vad">]>>;
-        }, import("zod/v4/core").$strip>]>;
-        ditModelSrc: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
-            src: import("zod").ZodString;
-            name: import("zod").ZodOptional<import("zod").ZodString>;
-            modelId: import("zod").ZodOptional<import("zod").ZodString>;
-            registryPath: import("zod").ZodOptional<import("zod").ZodString>;
-            registrySource: import("zod").ZodOptional<import("zod").ZodString>;
-            blobCoreKey: import("zod").ZodOptional<import("zod").ZodString>;
-            blobIndex: import("zod").ZodOptional<import("zod").ZodNumber>;
-            engine: import("zod").ZodOptional<import("zod").ZodString>;
-            expectedSize: import("zod").ZodOptional<import("zod").ZodNumber>;
-            sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
-            addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
-                embeddings: "embeddings";
-                diffusion: "diffusion";
-                audiogen: "audiogen";
-                tts: "tts";
-                ocr: "ocr";
-                vla: "vla";
-                "llamacpp-completion": "llamacpp-completion";
-                "whispercpp-transcription": "whispercpp-transcription";
-                "bci-whispercpp-transcription": "bci-whispercpp-transcription";
-                "llamacpp-embedding": "llamacpp-embedding";
-                "nmtcpp-translation": "nmtcpp-translation";
-                "onnx-tts": "onnx-tts";
-                "tts-ggml": "tts-ggml";
-                "parakeet-transcription": "parakeet-transcription";
-                "ggml-ocr": "ggml-ocr";
-                "sdcpp-generation": "sdcpp-generation";
-                "audiogen-ggml": "audiogen-ggml";
-                "ggml-vla": "ggml-vla";
-                "ggml-classification": "ggml-classification";
-                llm: "llm";
-                whisper: "whisper";
-                bci: "bci";
-                nmt: "nmt";
-                parakeet: "parakeet";
-                classification: "classification";
-            }>, import("zod").ZodLiteral<"vad">]>>;
-        }, import("zod/v4/core").$strip>]>;
-        vaeModelSrc: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
-            src: import("zod").ZodString;
-            name: import("zod").ZodOptional<import("zod").ZodString>;
-            modelId: import("zod").ZodOptional<import("zod").ZodString>;
-            registryPath: import("zod").ZodOptional<import("zod").ZodString>;
-            registrySource: import("zod").ZodOptional<import("zod").ZodString>;
-            blobCoreKey: import("zod").ZodOptional<import("zod").ZodString>;
-            blobIndex: import("zod").ZodOptional<import("zod").ZodNumber>;
-            engine: import("zod").ZodOptional<import("zod").ZodString>;
-            expectedSize: import("zod").ZodOptional<import("zod").ZodNumber>;
-            sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
-            addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
-                embeddings: "embeddings";
-                diffusion: "diffusion";
-                audiogen: "audiogen";
-                tts: "tts";
-                ocr: "ocr";
-                vla: "vla";
-                "llamacpp-completion": "llamacpp-completion";
-                "whispercpp-transcription": "whispercpp-transcription";
-                "bci-whispercpp-transcription": "bci-whispercpp-transcription";
-                "llamacpp-embedding": "llamacpp-embedding";
-                "nmtcpp-translation": "nmtcpp-translation";
-                "onnx-tts": "onnx-tts";
-                "tts-ggml": "tts-ggml";
-                "parakeet-transcription": "parakeet-transcription";
-                "ggml-ocr": "ggml-ocr";
-                "sdcpp-generation": "sdcpp-generation";
-                "audiogen-ggml": "audiogen-ggml";
-                "ggml-vla": "ggml-vla";
-                "ggml-classification": "ggml-classification";
-                llm: "llm";
-                whisper: "whisper";
-                bci: "bci";
-                nmt: "nmt";
-                parakeet: "parakeet";
-                classification: "classification";
-            }>, import("zod").ZodLiteral<"vad">]>>;
-        }, import("zod/v4/core").$strip>]>;
-    }, import("zod/v4/core").$strict>;
-    skipPrimaryModelPathValidation: true;
-    resolveConfig: typeof resolveAudioGenConfig;
-    createModel(params: CreateModelParams): PluginModelResult;
-    handlers: {
-        audioGenStream: import("../../../../schemas/index.js").PluginHandlerDefinition<import("zod").ZodObject<{
-            type: import("zod").ZodLiteral<"audioGenStream">;
-            requestId: import("zod").ZodOptional<import("zod").ZodString>;
-            referenceAudio: import("zod").ZodOptional<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                type: import("zod").ZodLiteral<"base64">;
-                value: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-                type: import("zod").ZodLiteral<"filePath">;
-                value: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>], "type">>;
-            sourceAudio: import("zod").ZodOptional<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                type: import("zod").ZodLiteral<"base64">;
-                value: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-                type: import("zod").ZodLiteral<"filePath">;
-                value: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>], "type">>;
-            modelId: import("zod").ZodString;
-            caption: import("zod").ZodString;
-            lyrics: import("zod").ZodOptional<import("zod").ZodString>;
-            seed: import("zod").ZodOptional<import("zod").ZodNumber>;
-            vocalLanguage: import("zod").ZodOptional<import("zod").ZodString>;
-            bpm: import("zod").ZodOptional<import("zod").ZodNumber>;
-            keyscale: import("zod").ZodOptional<import("zod").ZodString>;
-            timesignature: import("zod").ZodOptional<import("zod").ZodString>;
-            duration: import("zod").ZodOptional<import("zod").ZodNumber>;
-            lmTemperature: import("zod").ZodOptional<import("zod").ZodNumber>;
-            lmTopP: import("zod").ZodOptional<import("zod").ZodNumber>;
-            lmTopK: import("zod").ZodOptional<import("zod").ZodNumber>;
-            lmCfgScale: import("zod").ZodOptional<import("zod").ZodNumber>;
-            lmPhase1: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            dcwEnabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            dcwScaler: import("zod").ZodOptional<import("zod").ZodNumber>;
-            dcwHighScaler: import("zod").ZodOptional<import("zod").ZodNumber>;
-            taskType: import("zod").ZodOptional<import("zod").ZodEnum<{
-                text2music: "text2music";
-                "cover-nofsq": "cover-nofsq";
-            }>>;
-            audioCoverStrength: import("zod").ZodOptional<import("zod").ZodNumber>;
-            coverNoiseStrength: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-            type: import("zod").ZodLiteral<"audioGenStream">;
-            progress: import("zod").ZodOptional<import("zod").ZodObject<{
-                stage: import("zod").ZodString;
-                step: import("zod").ZodNumber;
-                total: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>>;
-            data: import("zod").ZodOptional<import("zod").ZodString>;
-            sampleRate: import("zod").ZodOptional<import("zod").ZodNumber>;
-            channels: import("zod").ZodOptional<import("zod").ZodNumber>;
-            bitsPerSample: import("zod").ZodOptional<import("zod").ZodNumber>;
-            done: import("zod").ZodDefault<import("zod").ZodBoolean>;
-            stopReason: import("zod").ZodOptional<import("zod").ZodEnum<{
-                cancelled: "cancelled";
-                completed: "completed";
-            }>>;
-            stats: import("zod").ZodOptional<import("zod").ZodObject<{
-                audioDurationMs: import("zod").ZodOptional<import("zod").ZodNumber>;
-                totalTimeMs: import("zod").ZodOptional<import("zod").ZodNumber>;
-                realTimeFactor: import("zod").ZodOptional<import("zod").ZodNumber>;
-                backendDevice: import("zod").ZodOptional<import("zod").ZodNumber>;
-                backendId: import("zod").ZodOptional<import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>>;
-        }, import("zod/v4/core").$strict>>;
-    };
-};
-//# sourceMappingURL=plugin.d.ts.map

package/dist/server/bare/plugins/audiogen-ggml/plugin.js

@@ -1,58 +0,0 @@
-import { AudioGen } from '@qvac/audiogen-ggml';
-import { ADDON_AUDIOGEN, ModelType, audioGenConfigSchema, audioGenStreamRequestSchema, audioGenStreamResponseSchema, defineHandler, definePlugin } from '../../../../schemas/index.js';
-import { createStreamLogger, registerAddonLogger } from '../../../../logging/index.js';
-import { resolveAudioGenConfig } from '../../../../server/bare/plugins/audiogen-ggml/config.js';
-import { audioGenStream } from '../../../../server/bare/plugins/audiogen-ggml/ops/audio-gen-stream.js';
-import { ModelLoadFailedError } from '../../../../utils/errors-server.js';
-export const audioGenPlugin = definePlugin({
-    modelType: ModelType.audiogenGgml,
-    displayName: 'Audio Generation (GGML / ACE-Step)',
-    addonPackage: ADDON_AUDIOGEN,
-    loadConfigSchema: audioGenConfigSchema,
-    // AudioGen's primary `modelSrc` is intentionally empty: all required
-    // weights are config-owned artifacts resolved from the four model sources.
-    skipPrimaryModelPathValidation: true,
-    resolveConfig: resolveAudioGenConfig,
-    createModel(params) {
-        const config = (params.modelConfig ?? {});
-        const textEncModel = params.artifacts?.['textEncModelPath'];
-        const lmModel = params.artifacts?.['lmModelPath'];
-        const ditModel = params.artifacts?.['ditModelPath'];
-        const vaeModel = params.artifacts?.['vaeModelPath'];
-        if (!textEncModel || !lmModel || !ditModel || !vaeModel) {
-            throw new ModelLoadFailedError('AudioGen requires resolved text encoder, LM, DiT, and VAE model artifacts');
-        }
-        const logger = createStreamLogger(params.modelId, ModelType.audiogenGgml);
-        const addonConfig = {
-            ...(config.useGPU !== undefined && { useGPU: config.useGPU }),
-            ...(config.inferenceSteps !== undefined && {
-                inferenceSteps: config.inferenceSteps
-            }),
-            ...(config.shift !== undefined && { shift: config.shift }),
-            ...(config.nGpuLayers !== undefined && { nGpuLayers: config.nGpuLayers }),
-            ...(config.threads !== undefined && { threads: config.threads }),
-            ...(config.backendsDir !== undefined && { backendsDir: config.backendsDir })
-        };
-        const model = new AudioGen({
-            files: {
-                textEncModel,
-                lmModel,
-                ditModel,
-                vaeModel
-            },
-            config: addonConfig,
-            logger
-        });
-        registerAddonLogger(params.modelId, ModelType.audiogenGgml, logger);
-        return { model };
-    },
-    handlers: {
-        audioGenStream: defineHandler({
-            requestSchema: audioGenStreamRequestSchema,
-            responseSchema: audioGenStreamResponseSchema,
-            streaming: true,
-            cancel: { scope: 'model', hard: true },
-            handler: audioGenStream
-        })
-    }
-});

package/dist/server/bare/plugins/bci-whispercpp-transcription/args.d.ts

@@ -1,3 +0,0 @@
-import type { BCIWhispercppArgs } from '@qvac/bci-whispercpp';
-export declare function buildBciWhispercppArgs(modelPath: string, embedderPath: string, logger: NonNullable<BCIWhispercppArgs['logger']>): BCIWhispercppArgs;
-//# sourceMappingURL=args.d.ts.map

package/dist/server/bare/plugins/bci-whispercpp-transcription/args.js

@@ -1,13 +0,0 @@
-export function buildBciWhispercppArgs(modelPath, embedderPath, logger) {
-    const args = {
-        files: {
-            model: modelPath,
-            ...(embedderPath ? { embedder: embedderPath } : {})
-        },
-        logger,
-        opts: {
-            stats: true
-        }
-    };
-    return args;
-}