@qvac/sdk 0.15.0 → 0.17.0

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

@@ -0,0 +1,213 @@
+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>;
+            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>;
+        }, 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

@@ -0,0 +1,58 @@
+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/plugin.d.ts

@@ -1,5 +1,6 @@
-import { type CreateModelParams, type PluginModelResult } from '../../../../schemas/index';
-import { resolveBciConfig } from './resolve-config';
+import bciAddonLogging from '@qvac/bci-whispercpp/addonLogging';
+import { type CreateModelParams, type PluginModelResult } from '../../../../schemas/index.js';
+import { resolveBciConfig } from '../../../../server/bare/plugins/bci-whispercpp-transcription/resolve-config.js';
 export declare const bciPlugin: {
     modelType: "bci-whispercpp-transcription";
     displayName: string;
@@ -50,6 +51,7 @@ export declare const bciPlugin: {
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
                 embeddings: "embeddings";
                 diffusion: "diffusion";
+                audiogen: "audiogen";
                 tts: "tts";
                 ocr: "ocr";
                 vla: "vla";
@@ -63,6 +65,7 @@ export declare const bciPlugin: {
                 "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";
@@ -77,7 +80,7 @@ export declare const bciPlugin: {
     resolveConfig: typeof resolveBciConfig;
     createModel(params: CreateModelParams): PluginModelResult;
     handlers: {
-        bciTranscribe: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
+        bciTranscribe: import("../../../../schemas/index.js").PluginHandlerDefinition<import("zod").ZodObject<{
             modelId: import("zod").ZodString;
             metadata: import("zod").ZodOptional<import("zod").ZodBoolean>;
             neuralData: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
@@ -119,7 +122,7 @@ export declare const bciPlugin: {
             }, import("zod/v4/core").$strip>>;
             type: import("zod").ZodLiteral<"bciTranscribe">;
         }, import("zod/v4/core").$strip>>;
-        bciTranscribeStream: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
+        bciTranscribeStream: import("../../../../schemas/index.js").PluginHandlerDefinition<import("zod").ZodObject<{
             modelId: import("zod").ZodString;
             metadata: import("zod").ZodOptional<import("zod").ZodBoolean>;
             type: import("zod").ZodLiteral<"bciTranscribeStream">;
@@ -164,7 +167,7 @@ export declare const bciPlugin: {
         }, import("zod/v4/core").$strip>>;
     };
     logging: {
-        module: import("@qvac/bci-whispercpp/addonLogging").AddonLogging;
+        module: typeof bciAddonLogging;
         namespace: "bci-whispercpp-transcription";
     };
 };

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

@@ -1,11 +1,11 @@
-import bciAddonLogging from '@qvac/bci-whispercpp/addonLogging.js';
+import bciAddonLogging from '@qvac/bci-whispercpp/addonLogging';
 import BCIWhispercpp, {} from '@qvac/bci-whispercpp';
 import { definePlugin, defineHandler, defineDuplexHandler, bciTranscribeRequestSchema, bciTranscribeResponseSchema, bciTranscribeStreamRequestSchema, bciTranscribeStreamResponseSchema, ModelType, bciConfigSchema, ADDON_BCI } from '../../../../schemas/index.js';
 import { createStreamLogger, registerAddonLogger } from '../../../../logging/index.js';
-import { bciTranscribe, bciTranscribeStream } from '../../ops/bci-transcribe.js';
+import { bciTranscribe, bciTranscribeStream } from '../../../../server/bare/ops/bci-transcribe.js';
 import { attachModelExecutionMs } from '../../../../profiling/model-execution.js';
-import { buildBciWhispercppArgs } from './args.js';
-import { resolveBciConfig } from './resolve-config.js';
+import { buildBciWhispercppArgs } from '../../../../server/bare/plugins/bci-whispercpp-transcription/args.js';
+import { resolveBciConfig } from '../../../../server/bare/plugins/bci-whispercpp-transcription/resolve-config.js';
 function createBciModel(modelId, modelPath, bciConfig, embedderPath) {
     const logger = createStreamLogger(modelId, ModelType.bciWhispercppTranscription);
     registerAddonLogger(modelId, ModelType.bciWhispercppTranscription, logger);

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

@@ -1,4 +1,4 @@
-import type { BciConfig, ResolveContext } from '../../../../schemas/index';
+import type { BciConfig, ResolveContext } from '../../../../schemas/index.js';
 export declare function resolveBciConfig(cfg: BciConfig, ctx: ResolveContext): Promise<{
     config: {
         whisperConfig?: {

package/dist/server/bare/plugins/ggml-classification/ops/classify.d.ts

@@ -1,4 +1,4 @@
-import { type ClassifyRequest, type ClassificationResult } from '../../../../../schemas/index';
+import { type ClassifyRequest, type ClassificationResult } from '../../../../../schemas/index.js';
 export declare function classify(params: ClassifyRequest): Promise<{
     results: ClassificationResult[];
     modelExecutionMs: number;

package/dist/server/bare/plugins/ggml-classification/ops/classify.js

@@ -1,4 +1,4 @@
-import { getModel } from '../../../registry/model-registry.js';
+import { getModel } from '../../../../../server/bare/registry/model-registry.js';
 import { classifyRequestSchema } from '../../../../../schemas/index.js';
 import { nowMs } from '../../../../../profiling/index.js';
 function hasClassify(model) {

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

@@ -1,4 +1,4 @@
-import { type CreateModelParams, type PluginModelResult } from '../../../../schemas/index';
+import { type CreateModelParams, type PluginModelResult } from '../../../../schemas/index.js';
 export declare const classificationPlugin: {
     modelType: "ggml-classification";
     displayName: string;
@@ -11,7 +11,7 @@ export declare const classificationPlugin: {
     skipPrimaryModelPathValidation: true;
     createModel(params: CreateModelParams): PluginModelResult;
     handlers: {
-        classify: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
+        classify: import("../../../../schemas/index.js").PluginHandlerDefinition<import("zod").ZodObject<{
             modelId: import("zod").ZodString;
             image: import("zod").ZodString;
             topK: import("zod").ZodOptional<import("zod").ZodNumber>;

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

@@ -1,7 +1,7 @@
 import ImageClassifier from '@qvac/classification-ggml';
 import { definePlugin, defineHandler, classifyRequestSchema, classifyResponseSchema, ModelType, classificationConfigSchema, ADDON_CLASSIFICATION } from '../../../../schemas/index.js';
 import { createStreamLogger, registerAddonLogger } from '../../../../logging/index.js';
-import { classify } from './ops/classify.js';
+import { classify } from '../../../../server/bare/plugins/ggml-classification/ops/classify.js';
 export const classificationPlugin = definePlugin({
     modelType: ModelType.ggmlClassification,
     displayName: 'Image Classification (GGML)',

package/dist/server/bare/plugins/ggml-ocr/ops/ocr-stream.d.ts

@@ -1,4 +1,4 @@
-import { type OCRParams, type OCRTextBlock, type OCRStats } from '../../../../../schemas/index';
+import { type OCRParams, type OCRTextBlock, type OCRStats } from '../../../../../schemas/index.js';
 export declare function ocr(params: OCRParams): AsyncGenerator<{
     blocks: OCRTextBlock[];
 }, {

package/dist/server/bare/plugins/ggml-ocr/ops/ocr-stream.js

@@ -1,9 +1,9 @@
-import { getModel } from '../../../registry/model-registry.js';
+import { getModel } from '../../../../../server/bare/registry/model-registry.js';
 import fs from 'bare-fs';
 import path from 'bare-path';
 import {} from '../../../../../schemas/index.js';
 import { buildStreamResult, hasDefinedValues } from '../../../../../profiling/model-execution.js';
-import { getCacheDir } from '../../../../utils/index.js';
+import { getCacheDir } from '../../../../../server/utils/index.js';
 import { ImageFileNotFoundError, InvalidImageInputError } from '../../../../../utils/errors-server.js';
 import { nowMs } from '../../../../../profiling/index.js';
 function polygonToBbox(polygon) {

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

@@ -1,4 +1,4 @@
-import { type CreateModelParams, type PluginModelResult, type OCRConfig, type ResolveContext, type ResolveResult } from '../../../../schemas/index';
+import { type CreateModelParams, type PluginModelResult, type OCRConfig, type ResolveContext, type ResolveResult } from '../../../../schemas/index.js';
 export declare const ocrPlugin: {
     modelType: "ggml-ocr";
     displayName: string;
@@ -37,6 +37,7 @@ export declare const ocrPlugin: {
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
                 embeddings: "embeddings";
                 diffusion: "diffusion";
+                audiogen: "audiogen";
                 tts: "tts";
                 ocr: "ocr";
                 vla: "vla";
@@ -50,6 +51,7 @@ export declare const ocrPlugin: {
                 "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";
@@ -64,7 +66,7 @@ export declare const ocrPlugin: {
     resolveConfig(cfg: OCRConfig, ctx: ResolveContext): Promise<ResolveResult<Record<string, unknown>, "detectorModelPath">>;
     createModel(params: CreateModelParams): PluginModelResult;
     handlers: {
-        ocrStream: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
+        ocrStream: import("../../../../schemas/index.js").PluginHandlerDefinition<import("zod").ZodObject<{
             modelId: import("zod").ZodString;
             image: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
                 type: import("zod").ZodLiteral<"base64">;

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

@@ -1,23 +1,11 @@
 import { definePlugin, defineHandler, ocrStreamRequestSchema, ocrStreamResponseSchema, ModelType, ocrConfigSchema, ADDON_OCR } from '../../../../schemas/index.js';
 import { ModelLoadFailedError } from '../../../../utils/errors-server.js';
-import { hyperdriveUrlSchema } from '../../../../schemas/load-model.js';
 import { createStreamLogger, registerAddonLogger } from '../../../../logging/index.js';
-import ocrAddonLogging from '@qvac/ocr-ggml/addonLogging.js';
+import ocrAddonLogging from '@qvac/ocr-ggml/addonLogging';
 import { OcrGgml } from '@qvac/ocr-ggml';
-import { ocr } from './ops/ocr-stream.js';
+import { ocr } from '../../../../server/bare/plugins/ggml-ocr/ops/ocr-stream.js';
 import { attachModelExecutionMs } from '../../../../profiling/model-execution.js';
-import { OCR_CRAFT } from '../../../../models/registry/index.js';
-const OCR_DETECTOR_FILENAME = 'craft_mlt_25k.gguf';
-function deriveDetectorSource(modelSrc) {
-    if (modelSrc.startsWith('pear://')) {
-        const { key } = hyperdriveUrlSchema.parse(modelSrc);
-        return `pear://${key}/${OCR_DETECTOR_FILENAME}`;
-    }
-    if (modelSrc.startsWith('registry://')) {
-        return OCR_CRAFT.src;
-    }
-    return undefined;
-}
+import { resolveOcrConfig } from '../../../../server/bare/plugins/ggml-ocr/resolve-config.js';
 function createOCRModel(modelId, detectorPath, recognizerPath, ocrConfig) {
     const logger = createStreamLogger(modelId, ModelType.ggmlOcr);
     registerAddonLogger(modelId, ModelType.ggmlOcr, logger);
@@ -66,16 +54,7 @@ export const ocrPlugin = definePlugin({
     addonPackage: ADDON_OCR,
     loadConfigSchema: ocrConfigSchema,
     async resolveConfig(cfg, ctx) {
-        const { detectorModelSrc, ...ocrConfig } = cfg;
-        const detectorSrc = detectorModelSrc ?? deriveDetectorSource(ctx.modelSrc);
-        if (!detectorSrc) {
-            throw new ModelLoadFailedError('Detector model required for OCR. Use a hyperdrive source or provide detectorModelSrc');
-        }
-        const detectorModelPath = await ctx.resolveModelPath(detectorSrc);
-        return {
-            config: ocrConfig,
-            artifacts: { detectorModelPath }
-        };
+        return resolveOcrConfig(cfg, ctx);
     },
     createModel(params) {
         const ocrConfig = (params.modelConfig ?? {});

package/dist/server/bare/plugins/ggml-ocr/resolve-config.d.ts

@@ -0,0 +1,6 @@
+import { type OCRConfig, type ResolveContext, type ResolveResult } from '../../../../schemas/index.js';
+type OcrPipelineType = NonNullable<OCRConfig['pipelineType']>;
+export declare const DETECTOR_FILENAMES: Record<OcrPipelineType, string>;
+export declare function resolveOcrConfig(cfg: OCRConfig, ctx: ResolveContext): Promise<ResolveResult<Record<string, unknown>, 'detectorModelPath'>>;
+export {};
+//# sourceMappingURL=resolve-config.d.ts.map

package/dist/server/bare/plugins/ggml-ocr/resolve-config.js

@@ -0,0 +1,73 @@
+import {} from '../../../../schemas/index.js';
+import { ModelLoadFailedError } from '../../../../utils/errors-server.js';
+import { hyperdriveUrlSchema } from '../../../../schemas/load-model.js';
+import { OCR_CRAFT, OCR_DOCTR_1 } from '../../../../models/registry/index.js';
+// Detector weights paired with each pipeline. EasyOCR runs CRAFT
+// detection, DocTR runs DBNet detection — the addon cannot load one
+// pipeline's detector into the other.
+export const DETECTOR_FILENAMES = {
+    easyocr: 'craft_mlt_25k.gguf',
+    doctr: 'db_mobilenet_v3_large.gguf'
+};
+const DETECTOR_REGISTRY_SOURCES = {
+    easyocr: OCR_CRAFT.src,
+    doctr: OCR_DOCTR_1.src
+};
+// The addon defaults to the EasyOCR pipeline, so a DocTR recognizer
+// loaded without an explicit `pipelineType` dies deep in the EasyOCR
+// CRNN weight loader with a raw missing-tensor error (QVAC-22514).
+// Recognize the known DocTR registry artifacts by name and opt in to
+// the DocTR pipeline automatically.
+function inferPipelineType(recognizerSrc) {
+    const path = srcPathname(recognizerSrc);
+    const filename = path.split('/').pop() ?? '';
+    if (filename === 'crnn_mobilenet_v3_small.gguf' || path.includes('/gguf/doctr')) {
+        return 'doctr';
+    }
+    return undefined;
+}
+function srcPathname(src) {
+    return (src.split(/[?#]/)[0] ?? '').toLowerCase();
+}
+function srcToString(src) {
+    return typeof src === 'string' ? src : src.src;
+}
+// The registry still lists legacy `.onnx` OCR artifacts under the
+// "@qvac/ocr-onnx" engine; the ggml-ocr addon can only open GGUF, so a
+// raw "failed to open GGUF" surfaces mid-load. Fail fast with the
+// supported configurations instead (QVAC-22514).
+function assertGgufSource(src, role) {
+    if (!srcPathname(src).endsWith('.onnx'))
+        return;
+    throw new ModelLoadFailedError(`ggml-ocr only loads GGUF models, but the ${role} source points to an ONNX file: ${src}. ` +
+        'The .onnx OCR registry entries are legacy artifacts of the removed "onnx-ocr" engine. ' +
+        'Supported registry configurations: EasyOCR (default) — modelSrc: OCR_LATIN.src (detector OCR_CRAFT auto-derived); ' +
+        'DocTR — modelSrc: OCR_DOCTR.src (pipelineType and detector OCR_DOCTR_1 auto-derived).');
+}
+function deriveDetectorSource(modelSrc, pipelineType) {
+    if (modelSrc.startsWith('pear://')) {
+        const { key } = hyperdriveUrlSchema.parse(modelSrc);
+        return `pear://${key}/${DETECTOR_FILENAMES[pipelineType]}`;
+    }
+    if (modelSrc.startsWith('registry://')) {
+        return DETECTOR_REGISTRY_SOURCES[pipelineType];
+    }
+    return undefined;
+}
+export async function resolveOcrConfig(cfg, ctx) {
+    const { detectorModelSrc, ...ocrConfig } = cfg;
+    assertGgufSource(ctx.modelSrc, 'recognizer');
+    const pipelineType = ocrConfig.pipelineType ?? inferPipelineType(ctx.modelSrc) ?? 'easyocr';
+    const detectorSrc = detectorModelSrc ?? deriveDetectorSource(ctx.modelSrc, pipelineType);
+    if (!detectorSrc) {
+        throw new ModelLoadFailedError(`Detector model required for OCR (${pipelineType} pipeline expects ` +
+            `${DETECTOR_FILENAMES[pipelineType]}). Use a hyperdrive or registry ` +
+            'source, or provide detectorModelSrc');
+    }
+    assertGgufSource(srcToString(detectorSrc), 'detector');
+    const detectorModelPath = await ctx.resolveModelPath(detectorSrc);
+    return {
+        config: { ...ocrConfig, pipelineType },
+        artifacts: { detectorModelPath }
+    };
+}

package/dist/server/bare/plugins/ggml-vla/ops/vla-hparams.d.ts

@@ -1,3 +1,3 @@
-import { type VlaHparamsRequest, type VlaHparamsResponse } from '../../../../../schemas/index';
+import { type VlaHparamsRequest, type VlaHparamsResponse } from '../../../../../schemas/index.js';
 export declare function vlaGetHparams(request: VlaHparamsRequest): Promise<VlaHparamsResponse>;
 //# sourceMappingURL=vla-hparams.d.ts.map

package/dist/server/bare/plugins/ggml-vla/ops/vla-hparams.js

@@ -1,4 +1,4 @@
-import { getModel } from '../../../registry/model-registry.js';
+import { getModel } from '../../../../../server/bare/registry/model-registry.js';
 import { vlaHparamsSchema } from '../../../../../schemas/index.js';
 export function vlaGetHparams(request) {
     const model = getModel(request.modelId);

package/dist/server/bare/plugins/ggml-vla/ops/vla-run.d.ts

@@ -1,3 +1,3 @@
-import { type VlaRunRequest, type VlaRunResponse } from '../../../../../schemas/index';
+import { type VlaRunRequest, type VlaRunResponse } from '../../../../../schemas/index.js';
 export declare function vlaRun(request: VlaRunRequest): Promise<VlaRunResponse>;
 //# sourceMappingURL=vla-run.d.ts.map

package/dist/server/bare/plugins/ggml-vla/ops/vla-run.js

@@ -1,4 +1,4 @@
-import { getModel } from '../../../registry/model-registry.js';
+import { getModel } from '../../../../../server/bare/registry/model-registry.js';
 import {} from '../../../../../schemas/index.js';
 import { decodeBase64, encodeBase64 } from '../../../../../utils/encoding.js';
 function f32FromBase64(b64) {