@qvac/sdk 0.8.2 → 0.9.0

package/dist/server/bare/plugins/parakeet-transcription/plugin.d.ts

@@ -52,6 +52,7 @@ export declare const parakeetPlugin: {
                 "onnx-tts": "onnx-tts";
                 "parakeet-transcription": "parakeet-transcription";
                 "onnx-ocr": "onnx-ocr";
+                "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
                 embeddings: "embeddings";
@@ -59,34 +60,7 @@ export declare const parakeetPlugin: {
                 parakeet: "parakeet";
                 tts: "tts";
                 ocr: "ocr";
-            }>, import("zod").ZodLiteral<"vad">]>>;
-        }, import("zod/v4/core").$strip>]>>;
-        parakeetEncoderDataSrc: import("zod").ZodOptional<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<{
-                "llamacpp-completion": "llamacpp-completion";
-                "whispercpp-transcription": "whispercpp-transcription";
-                "llamacpp-embedding": "llamacpp-embedding";
-                "nmtcpp-translation": "nmtcpp-translation";
-                "onnx-tts": "onnx-tts";
-                "parakeet-transcription": "parakeet-transcription";
-                "onnx-ocr": "onnx-ocr";
-                llm: "llm";
-                whisper: "whisper";
-                embeddings: "embeddings";
-                nmt: "nmt";
-                parakeet: "parakeet";
-                tts: "tts";
-                ocr: "ocr";
+                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
         parakeetDecoderSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
@@ -108,6 +82,7 @@ export declare const parakeetPlugin: {
                 "onnx-tts": "onnx-tts";
                 "parakeet-transcription": "parakeet-transcription";
                 "onnx-ocr": "onnx-ocr";
+                "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
                 embeddings: "embeddings";
@@ -115,6 +90,7 @@ export declare const parakeetPlugin: {
                 parakeet: "parakeet";
                 tts: "tts";
                 ocr: "ocr";
+                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
         parakeetVocabSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
@@ -136,6 +112,7 @@ export declare const parakeetPlugin: {
                 "onnx-tts": "onnx-tts";
                 "parakeet-transcription": "parakeet-transcription";
                 "onnx-ocr": "onnx-ocr";
+                "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
                 embeddings: "embeddings";
@@ -143,6 +120,7 @@ export declare const parakeetPlugin: {
                 parakeet: "parakeet";
                 tts: "tts";
                 ocr: "ocr";
+                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
         parakeetPreprocessorSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
@@ -164,6 +142,7 @@ export declare const parakeetPlugin: {
                 "onnx-tts": "onnx-tts";
                 "parakeet-transcription": "parakeet-transcription";
                 "onnx-ocr": "onnx-ocr";
+                "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
                 embeddings: "embeddings";
@@ -171,6 +150,7 @@ export declare const parakeetPlugin: {
                 parakeet: "parakeet";
                 tts: "tts";
                 ocr: "ocr";
+                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
         parakeetCtcModelSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
@@ -192,6 +172,7 @@ export declare const parakeetPlugin: {
                 "onnx-tts": "onnx-tts";
                 "parakeet-transcription": "parakeet-transcription";
                 "onnx-ocr": "onnx-ocr";
+                "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
                 embeddings: "embeddings";
@@ -199,34 +180,7 @@ export declare const parakeetPlugin: {
                 parakeet: "parakeet";
                 tts: "tts";
                 ocr: "ocr";
-            }>, import("zod").ZodLiteral<"vad">]>>;
-        }, import("zod/v4/core").$strip>]>>;
-        parakeetCtcModelDataSrc: import("zod").ZodOptional<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<{
-                "llamacpp-completion": "llamacpp-completion";
-                "whispercpp-transcription": "whispercpp-transcription";
-                "llamacpp-embedding": "llamacpp-embedding";
-                "nmtcpp-translation": "nmtcpp-translation";
-                "onnx-tts": "onnx-tts";
-                "parakeet-transcription": "parakeet-transcription";
-                "onnx-ocr": "onnx-ocr";
-                llm: "llm";
-                whisper: "whisper";
-                embeddings: "embeddings";
-                nmt: "nmt";
-                parakeet: "parakeet";
-                tts: "tts";
-                ocr: "ocr";
+                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
         parakeetTokenizerSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
@@ -248,6 +202,7 @@ export declare const parakeetPlugin: {
                 "onnx-tts": "onnx-tts";
                 "parakeet-transcription": "parakeet-transcription";
                 "onnx-ocr": "onnx-ocr";
+                "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
                 embeddings: "embeddings";
@@ -255,6 +210,7 @@ export declare const parakeetPlugin: {
                 parakeet: "parakeet";
                 tts: "tts";
                 ocr: "ocr";
+                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
         parakeetSortformerSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
@@ -276,6 +232,7 @@ export declare const parakeetPlugin: {
                 "onnx-tts": "onnx-tts";
                 "parakeet-transcription": "parakeet-transcription";
                 "onnx-ocr": "onnx-ocr";
+                "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
                 embeddings: "embeddings";
@@ -283,6 +240,7 @@ export declare const parakeetPlugin: {
                 parakeet: "parakeet";
                 tts: "tts";
                 ocr: "ocr";
+                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
     }, import("zod/v4/core").$strip>;
@@ -290,8 +248,9 @@ export declare const parakeetPlugin: {
     resolveConfig(cfg: ParakeetModelConfig, ctx: ResolveContext): Promise<ResolveResult<ParakeetModelConfig>>;
     createModel(params: CreateModelParams): PluginModelResult;
     handlers: {
-        transcribeStream: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
+        transcribe: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
             modelId: import("zod").ZodString;
+            prompt: import("zod").ZodOptional<import("zod").ZodString>;
             audioChunk: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
                 type: import("zod").ZodLiteral<"base64">;
                 value: import("zod").ZodString;
@@ -299,13 +258,24 @@ export declare const parakeetPlugin: {
                 type: import("zod").ZodLiteral<"filePath">;
                 value: import("zod").ZodString;
             }, import("zod/v4/core").$strip>], "type">;
-            prompt: import("zod").ZodOptional<import("zod").ZodString>;
-            type: import("zod").ZodLiteral<"transcribeStream">;
+            type: import("zod").ZodLiteral<"transcribe">;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-            type: import("zod").ZodLiteral<"transcribeStream">;
             text: import("zod").ZodOptional<import("zod").ZodString>;
             done: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            stats: import("zod").ZodOptional<import("zod").ZodObject<{
+                audioDuration: import("zod").ZodOptional<import("zod").ZodNumber>;
+                realTimeFactor: import("zod").ZodOptional<import("zod").ZodNumber>;
+                tokensPerSecond: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalSegments: import("zod").ZodOptional<import("zod").ZodNumber>;
+                whisperEncodeTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+                whisperDecodeTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+                encoderTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+                decoderTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+                melSpecTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>>;
             error: import("zod").ZodOptional<import("zod").ZodString>;
+            type: import("zod").ZodLiteral<"transcribe">;
         }, import("zod/v4/core").$strip>>;
     };
     logging: {

package/dist/server/bare/plugins/parakeet-transcription/plugin.js

@@ -1,11 +1,12 @@
 import parakeetAddonLogging from "@qvac/transcription-parakeet/addonLogging.js";
 import TranscriptionParakeet, {} from "@qvac/transcription-parakeet";
-import { definePlugin, defineHandler, transcribeStreamRequestSchema, transcribeStreamResponseSchema, ModelType, parakeetConfigSchema, ADDON_PARAKEET, } from "../../../../schemas/index.js";
+import { definePlugin, defineHandler, transcribeRequestSchema, transcribeResponseSchema, ModelType, parakeetConfigSchema, ADDON_PARAKEET, } from "../../../../schemas/index.js";
 import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
 import { parseModelPath } from "../../../utils/index.js";
 import { ModelLoadFailedError, ParakeetArtifactsRequiredError, } from "../../../../utils/errors-server.js";
 import FilesystemDL from "@qvac/dl-filesystem";
 import { transcribe } from "../../ops/transcribe.js";
+import { attachModelExecutionMs } from "../../../../profiling/model-execution.js";
 async function resolveTdtConfig(cfg, ctx) {
     const { parakeetEncoderSrc, parakeetEncoderDataSrc, parakeetDecoderSrc, parakeetVocabSrc, parakeetPreprocessorSrc, } = cfg;
     if (!parakeetEncoderSrc ||
@@ -25,11 +26,11 @@ async function resolveTdtConfig(cfg, ctx) {
     return {
         config: cfg,
         artifacts: {
-            encoderPath,
-            ...(encoderDataPath !== undefined && { encoderDataPath }),
-            ...(decoderPath !== undefined && { decoderPath }),
-            ...(vocabPath !== undefined && { vocabPath }),
-            ...(preprocessorPath !== undefined && { preprocessorPath }),
+            encoder: encoderPath,
+            ...(encoderDataPath !== undefined && { encoderData: encoderDataPath }),
+            ...(decoderPath !== undefined && { decoder: decoderPath }),
+            ...(vocabPath !== undefined && { vocab: vocabPath }),
+            ...(preprocessorPath !== undefined && { preprocessor: preprocessorPath }),
         },
     };
 }
@@ -47,9 +48,9 @@ async function resolveCtcConfig(cfg, ctx) {
     return {
         config: cfg,
         artifacts: {
-            ctcModelPath,
-            ...(ctcModelDataPath !== undefined && { ctcModelDataPath }),
-            ...(tokenizerPath !== undefined && { tokenizerPath }),
+            model: ctcModelPath,
+            ...(ctcModelDataPath !== undefined && { modelData: ctcModelDataPath }),
+            ...(tokenizerPath !== undefined && { tokenizer: tokenizerPath }),
         },
     };
 }
@@ -63,15 +64,15 @@ async function resolveSortformerConfig(cfg, ctx) {
     return {
         config: cfg,
         artifacts: {
-            ...(sortformerPath !== undefined && { sortformerPath }),
+            ...(sortformerPath !== undefined && { sortformer: sortformerPath }),
         },
     };
 }
-function createParakeetModel(params, addonPathKey) {
+function createParakeetModel(params, primaryFileKey) {
     const config = (params.modelConfig ?? {});
-    const artifacts = params.artifacts ?? {};
+    const artifacts = { ...(params.artifacts ?? {}) };
     const modelType = config.modelType ?? "tdt";
-    const primaryPath = artifacts[addonPathKey] ?? params.modelPath;
+    const primaryPath = artifacts[primaryFileKey] ?? params.modelPath;
     if (!primaryPath) {
         throw new ModelLoadFailedError(`Parakeet ${modelType} requires a model source`);
     }
@@ -79,10 +80,12 @@ function createParakeetModel(params, addonPathKey) {
     const loader = new FilesystemDL({ dirPath });
     const logger = createStreamLogger(params.modelId, ModelType.parakeetTranscription);
     registerAddonLogger(params.modelId, ModelType.parakeetTranscription, logger);
-    const addonConfig = {
-        path: dirPath,
-        [addonPathKey]: primaryPath,
+    const files = {
+        [primaryFileKey]: primaryPath,
         ...artifacts,
+    };
+    const addonConfig = {
+        enableStats: true,
         parakeetConfig: {
             modelType,
             maxThreads: config.maxThreads,
@@ -94,11 +97,10 @@ function createParakeetModel(params, addonPathKey) {
         },
     };
     const model = new TranscriptionParakeet({
-        loader,
+        files,
+        config: addonConfig,
         logger,
-        modelName: parseModelPath(dirPath).basePath,
-        diskPath: dirPath,
-    }, addonConfig);
+    });
     return { model, loader };
 }
 export const parakeetPlugin = definePlugin({
@@ -118,32 +120,42 @@ export const parakeetPlugin = definePlugin({
     createModel(params) {
         const modelType = (params.modelConfig ?? {}).modelType ?? "tdt";
         if (modelType === "ctc")
-            return createParakeetModel(params, "ctcModelPath");
+            return createParakeetModel(params, "model");
         if (modelType === "sortformer")
-            return createParakeetModel(params, "sortformerPath");
-        return createParakeetModel(params, "encoderPath");
+            return createParakeetModel(params, "sortformer");
+        return createParakeetModel(params, "encoder");
     },
     handlers: {
-        transcribeStream: defineHandler({
-            requestSchema: transcribeStreamRequestSchema,
-            responseSchema: transcribeStreamResponseSchema,
+        transcribe: defineHandler({
+            requestSchema: transcribeRequestSchema,
+            responseSchema: transcribeResponseSchema,
             streaming: true,
             handler: async function* (request) {
-                for await (const text of transcribe({
+                const stream = transcribe({
                     modelId: request.modelId,
                     audioChunk: request.audioChunk,
                     prompt: request.prompt,
-                })) {
-                    yield {
-                        type: "transcribeStream",
-                        text,
-                    };
+                });
+                try {
+                    let result = await stream.next();
+                    while (!result.done) {
+                        yield {
+                            type: "transcribe",
+                            text: result.value,
+                        };
+                        result = await stream.next();
+                    }
+                    const { modelExecutionMs, stats } = result.value;
+                    yield attachModelExecutionMs({
+                        type: "transcribe",
+                        text: "",
+                        done: true,
+                        ...(stats && { stats }),
+                    }, modelExecutionMs);
+                }
+                finally {
+                    await stream.return?.(undefined);
                 }
-                yield {
-                    type: "transcribeStream",
-                    text: "",
-                    done: true,
-                };
             },
         }),
     },

package/dist/server/bare/plugins/sdcpp-generation/ops/diffusion.d.ts

@@ -0,0 +1,3 @@
+import type { DiffusionRequest, DiffusionStreamResponse } from "../../../../../schemas/sdcpp-config";
+export declare function diffusion(request: DiffusionRequest): AsyncGenerator<DiffusionStreamResponse>;
+//# sourceMappingURL=diffusion.d.ts.map

package/dist/server/bare/plugins/sdcpp-generation/ops/diffusion.js

@@ -0,0 +1,51 @@
+import { getModel } from "../../../registry/model-registry.js";
+export async function* diffusion(request) {
+    const model = getModel(request.modelId);
+    const response = await model.run({
+        prompt: request.prompt,
+        negative_prompt: request.negative_prompt,
+        width: request.width,
+        height: request.height,
+        steps: request.steps,
+        cfg_scale: request.cfg_scale,
+        guidance: request.guidance,
+        sampling_method: request.sampling_method,
+        scheduler: request.scheduler,
+        seed: request.seed,
+        batch_count: request.batch_count,
+        vae_tiling: request.vae_tiling,
+        cache_preset: request.cache_preset,
+    });
+    let outputIndex = 0;
+    for await (const chunk of response.iterate()) {
+        if (chunk instanceof Uint8Array) {
+            yield {
+                type: "diffusionStream",
+                data: Buffer.from(chunk).toString("base64"),
+                outputIndex: outputIndex++,
+            };
+        }
+        else if (typeof chunk === "string") {
+            try {
+                const tick = JSON.parse(chunk);
+                if ("step" in tick) {
+                    yield {
+                        type: "diffusionStream",
+                        step: tick["step"],
+                        totalSteps: tick["total"],
+                        elapsedMs: tick["elapsed_ms"],
+                    };
+                }
+            }
+            catch {
+                // Non-JSON string output — skip
+            }
+        }
+    }
+    const responseWithStats = response;
+    yield {
+        type: "diffusionStream",
+        done: true,
+        stats: responseWithStats.stats ?? undefined,
+    };
+}