@qvac/sdk 0.8.3 → 0.9.0

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

@@ -0,0 +1,278 @@
+import { type CreateModelParams, type PluginModelResult, type ResolveContext, type ResolveResult, type SdcppConfig } from "../../../../schemas/index";
+type DiffusionArtifactKey = "clipLModelPath" | "clipGModelPath" | "t5XxlModelPath" | "llmModelPath" | "vaeModelPath";
+export declare const diffusionPlugin: {
+    modelType: "sdcpp-generation";
+    displayName: string;
+    addonPackage: "@qvac/diffusion-cpp";
+    loadConfigSchema: import("zod").ZodObject<{
+        threads: import("zod").ZodOptional<import("zod").ZodNumber>;
+        device: import("zod").ZodOptional<import("zod").ZodEnum<{
+            cpu: "cpu";
+            gpu: "gpu";
+        }>>;
+        prediction: import("zod").ZodOptional<import("zod").ZodEnum<{
+            auto: "auto";
+            eps: "eps";
+            v: "v";
+            edm_v: "edm_v";
+            flow: "flow";
+            flux_flow: "flux_flow";
+            flux2_flow: "flux2_flow";
+        }>>;
+        type: import("zod").ZodOptional<import("zod").ZodEnum<{
+            auto: "auto";
+            f32: "f32";
+            f16: "f16";
+            bf16: "bf16";
+            q2_k: "q2_k";
+            q3_k: "q3_k";
+            q4_0: "q4_0";
+            q4_1: "q4_1";
+            q4_k: "q4_k";
+            q5_0: "q5_0";
+            q5_1: "q5_1";
+            q5_k: "q5_k";
+            q6_k: "q6_k";
+            q8_0: "q8_0";
+        }>>;
+        rng: import("zod").ZodOptional<import("zod").ZodEnum<{
+            cpu: "cpu";
+            cuda: "cuda";
+            std_default: "std_default";
+        }>>;
+        sampler_rng: import("zod").ZodOptional<import("zod").ZodEnum<{
+            cpu: "cpu";
+            cuda: "cuda";
+            std_default: "std_default";
+        }>>;
+        clip_on_cpu: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        vae_on_cpu: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        vae_tiling: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        flash_attn: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        verbosity: import("zod").ZodOptional<import("zod").ZodNumber>;
+        clipLModelSrc: 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";
+                "sdcpp-generation": "sdcpp-generation";
+                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>]>>;
+        clipGModelSrc: 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";
+                "sdcpp-generation": "sdcpp-generation";
+                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>]>>;
+        t5XxlModelSrc: 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";
+                "sdcpp-generation": "sdcpp-generation";
+                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>]>>;
+        llmModelSrc: 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";
+                "sdcpp-generation": "sdcpp-generation";
+                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>]>>;
+        vaeModelSrc: 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";
+                "sdcpp-generation": "sdcpp-generation";
+                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>]>>;
+    }, import("zod/v4/core").$strip>;
+    resolveConfig(cfg: SdcppConfig, ctx: ResolveContext): Promise<ResolveResult<SdcppConfig, DiffusionArtifactKey>>;
+    createModel(params: CreateModelParams): PluginModelResult;
+    handlers: {
+        diffusionStream: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
+            modelId: import("zod").ZodString;
+            prompt: import("zod").ZodString;
+            negative_prompt: import("zod").ZodOptional<import("zod").ZodString>;
+            width: import("zod").ZodOptional<import("zod").ZodNumber>;
+            height: import("zod").ZodOptional<import("zod").ZodNumber>;
+            steps: import("zod").ZodOptional<import("zod").ZodNumber>;
+            cfg_scale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            guidance: import("zod").ZodOptional<import("zod").ZodNumber>;
+            sampling_method: import("zod").ZodOptional<import("zod").ZodEnum<{
+                euler: "euler";
+                euler_a: "euler_a";
+                heun: "heun";
+                dpm2: "dpm2";
+                "dpm++2m": "dpm++2m";
+                "dpm++2mv2": "dpm++2mv2";
+                "dpm++2s_a": "dpm++2s_a";
+                lcm: "lcm";
+                ipndm: "ipndm";
+                ipndm_v: "ipndm_v";
+                ddim_trailing: "ddim_trailing";
+                tcd: "tcd";
+                res_multistep: "res_multistep";
+                res_2s: "res_2s";
+            }>>;
+            scheduler: import("zod").ZodOptional<import("zod").ZodEnum<{
+                lcm: "lcm";
+                discrete: "discrete";
+                karras: "karras";
+                exponential: "exponential";
+                ays: "ays";
+                gits: "gits";
+                sgm_uniform: "sgm_uniform";
+                simple: "simple";
+                smoothstep: "smoothstep";
+                kl_optimal: "kl_optimal";
+                bong_tangent: "bong_tangent";
+            }>>;
+            seed: import("zod").ZodOptional<import("zod").ZodNumber>;
+            batch_count: import("zod").ZodOptional<import("zod").ZodNumber>;
+            vae_tiling: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            cache_preset: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"diffusionStream">;
+            step: import("zod").ZodOptional<import("zod").ZodNumber>;
+            totalSteps: import("zod").ZodOptional<import("zod").ZodNumber>;
+            elapsedMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+            data: import("zod").ZodOptional<import("zod").ZodString>;
+            outputIndex: import("zod").ZodOptional<import("zod").ZodNumber>;
+            done: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            stats: import("zod").ZodOptional<import("zod").ZodObject<{
+                modelLoadMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                generationMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalGenerationMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalWallMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalSteps: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalGenerations: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalImages: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalPixels: import("zod").ZodOptional<import("zod").ZodNumber>;
+                width: import("zod").ZodOptional<import("zod").ZodNumber>;
+                height: import("zod").ZodOptional<import("zod").ZodNumber>;
+                seed: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>>;
+    };
+    logging: {
+        module: import("@qvac/diffusion-cpp/addonLogging").AddonLogging;
+        namespace: "sdcpp-generation";
+    };
+};
+export {};
+//# sourceMappingURL=plugin.d.ts.map

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

@@ -0,0 +1,70 @@
+import ImgStableDiffusion, {} from "@qvac/diffusion-cpp";
+import addonLogging from "@qvac/diffusion-cpp/addonLogging.js";
+import { definePlugin, defineHandler, sdcppConfigSchema, diffusionRequestSchema, diffusionStreamResponseSchema, ModelType, ADDON_DIFFUSION, } from "../../../../schemas/index.js";
+import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
+import { parseModelPath } from "../../../utils/index.js";
+import { diffusion } from "./ops/diffusion.js";
+export const diffusionPlugin = definePlugin({
+    modelType: ModelType.sdcppGeneration,
+    displayName: "Image Generation (stable-diffusion.cpp)",
+    addonPackage: ADDON_DIFFUSION,
+    loadConfigSchema: sdcppConfigSchema,
+    async resolveConfig(cfg, ctx) {
+        const { clipLModelSrc, clipGModelSrc, t5XxlModelSrc, llmModelSrc, vaeModelSrc, ...runtimeConfig } = cfg;
+        const sources = { clipLModelSrc, clipGModelSrc, t5XxlModelSrc, llmModelSrc, vaeModelSrc };
+        const hasSources = Object.values(sources).some(Boolean);
+        if (!hasSources) {
+            return { config: runtimeConfig };
+        }
+        const resolve = ctx.resolveModelPath;
+        const [clipLModelPath, clipGModelPath, t5XxlModelPath, llmModelPath, vaeModelPath] = await Promise.all([
+            clipLModelSrc ? resolve(clipLModelSrc) : undefined,
+            clipGModelSrc ? resolve(clipGModelSrc) : undefined,
+            t5XxlModelSrc ? resolve(t5XxlModelSrc) : undefined,
+            llmModelSrc ? resolve(llmModelSrc) : undefined,
+            vaeModelSrc ? resolve(vaeModelSrc) : undefined,
+        ]);
+        return {
+            config: runtimeConfig,
+            artifacts: {
+                ...(clipLModelPath && { clipLModelPath }),
+                ...(clipGModelPath && { clipGModelPath }),
+                ...(t5XxlModelPath && { t5XxlModelPath }),
+                ...(llmModelPath && { llmModelPath }),
+                ...(vaeModelPath && { vaeModelPath }),
+            },
+        };
+    },
+    createModel(params) {
+        const { modelId, modelPath, modelConfig, artifacts } = params;
+        const config = (modelConfig ?? {});
+        const { dirPath, basePath } = parseModelPath(modelPath);
+        const logger = createStreamLogger(modelId, ModelType.sdcppGeneration);
+        registerAddonLogger(modelId, ModelType.sdcppGeneration, logger);
+        const addonArgs = {
+            diskPath: dirPath,
+            modelName: basePath,
+            logger,
+            opts: { stats: true },
+            ...(artifacts?.["clipLModelPath"] && { clipLModel: artifacts["clipLModelPath"] }),
+            ...(artifacts?.["clipGModelPath"] && { clipGModel: artifacts["clipGModelPath"] }),
+            ...(artifacts?.["t5XxlModelPath"] && { t5XxlModel: artifacts["t5XxlModelPath"] }),
+            ...(artifacts?.["llmModelPath"] && { llmModel: artifacts["llmModelPath"] }),
+            ...(artifacts?.["vaeModelPath"] && { vaeModel: artifacts["vaeModelPath"] }),
+        };
+        const model = new ImgStableDiffusion(addonArgs, config);
+        return { model, loader: undefined };
+    },
+    handlers: {
+        diffusionStream: defineHandler({
+            requestSchema: diffusionRequestSchema,
+            responseSchema: diffusionStreamResponseSchema,
+            streaming: true,
+            handler: diffusion,
+        }),
+    },
+    logging: {
+        module: addonLogging,
+        namespace: ModelType.sdcppGeneration,
+    },
+});

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

@@ -82,6 +82,7 @@ export declare const whisperPlugin: {
                 "onnx-tts": "onnx-tts";
                 "parakeet-transcription": "parakeet-transcription";
                 "onnx-ocr": "onnx-ocr";
+                "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
                 embeddings: "embeddings";
@@ -89,6 +90,7 @@ export declare const whisperPlugin: {
                 parakeet: "parakeet";
                 tts: "tts";
                 ocr: "ocr";
+                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
     }, import("zod/v4/core").$strip>;
@@ -211,8 +213,9 @@ export declare const whisperPlugin: {
     }>;
     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;
@@ -220,13 +223,46 @@ export declare const whisperPlugin: {
                 type: import("zod").ZodLiteral<"filePath">;
                 value: import("zod").ZodString;
             }, import("zod/v4/core").$strip>], "type">;
+            type: import("zod").ZodLiteral<"transcribe">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            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>>;
+        transcribeStream: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
+            modelId: import("zod").ZodString;
             prompt: import("zod").ZodOptional<import("zod").ZodString>;
             type: import("zod").ZodLiteral<"transcribeStream">;
         }, 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<"transcribeStream">;
         }, import("zod/v4/core").$strip>>;
     };
     logging: {

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

@@ -1,28 +1,20 @@
 import whisperAddonLogging from "@qvac/transcription-whispercpp/addonLogging.js";
 import TranscriptionWhispercpp, {} from "@qvac/transcription-whispercpp";
-import { definePlugin, defineHandler, transcribeStreamRequestSchema, transcribeStreamResponseSchema, ModelType, whisperConfigSchema, ADDON_WHISPER, } from "../../../../schemas/index.js";
+import { definePlugin, defineHandler, defineDuplexHandler, transcribeRequestSchema, transcribeResponseSchema, transcribeStreamRequestSchema, transcribeStreamResponseSchema, ModelType, whisperConfigSchema, ADDON_WHISPER, } from "../../../../schemas/index.js";
 import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
-import { parseModelPath } from "../../../utils/index.js";
-import FilesystemDL from "@qvac/dl-filesystem";
-import { transcribe } from "../../ops/transcribe.js";
+import { transcribe, transcribeStream } from "../../ops/transcribe.js";
+import { attachModelExecutionMs } from "../../../../profiling/model-execution.js";
 function createWhisperModel(modelId, modelPath, whisperConfig, vadModelPath) {
-    const { dirPath, basePath } = parseModelPath(modelPath);
-    let vadModelName = "";
-    if (vadModelPath) {
-        const vadParsed = parseModelPath(vadModelPath);
-        vadModelName = vadParsed.basePath;
-    }
-    const loader = new FilesystemDL({ dirPath });
     const logger = createStreamLogger(modelId, ModelType.whispercppTranscription);
     registerAddonLogger(modelId, ModelType.whispercppTranscription, logger);
     const args = {
-        loader,
+        files: {
+            model: modelPath,
+            ...(vadModelPath && { vadModel: vadModelPath }),
+        },
         logger,
-        modelName: basePath,
-        diskPath: dirPath,
-        vadModelName,
         opts: {
-            stats: false,
+            stats: true,
         },
     };
     const { contextParams, miscConfig, ...whisperParams } = whisperConfig;
@@ -32,7 +24,7 @@ function createWhisperModel(modelId, modelPath, whisperConfig, vadModelPath) {
         ...(miscConfig && { miscConfig }),
     };
     const model = new TranscriptionWhispercpp(args, config);
-    return { model, loader };
+    return { model, loader: null };
 }
 export const whisperPlugin = definePlugin({
     modelType: ModelType.whispercppTranscription,
@@ -56,16 +48,45 @@ export const whisperPlugin = definePlugin({
         return { model, loader };
     },
     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,
-                })) {
+                });
+                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);
+                }
+            },
+        }),
+        transcribeStream: defineDuplexHandler({
+            requestSchema: transcribeStreamRequestSchema,
+            responseSchema: transcribeStreamResponseSchema,
+            streaming: true,
+            duplex: true,
+            handler: async function* (request, inputStream) {
+                for await (const text of transcribeStream(request.modelId, inputStream, request.prompt)) {
                     yield {
                         type: "transcribeStream",
                         text,

package/dist/server/bare/rag-hyperdb/handlers/ingest.js

@@ -4,7 +4,8 @@ import { ragIngestParamsSchema } from "../../../../schemas/index.js";
 export async function ingest(params, options) {
     const { modelId, documents, chunk, chunkOpts, workspace, progressInterval } = ragIngestParamsSchema.parse(params);
     async function embeddingFunction(text) {
-        return await embed({ modelId, text });
+        const result = await embed({ modelId, text });
+        return result.embedding;
     }
     const rag = await getRagInstance(modelId, embeddingFunction, workspace);
     const ingestOpts = {

package/dist/server/bare/rag-hyperdb/handlers/search.js

@@ -7,7 +7,8 @@ export async function search(params) {
         return [];
     }
     async function embeddingFunction(text) {
-        return await embed({ modelId, text });
+        const result = await embed({ modelId, text });
+        return result.embedding;
     }
     const rag = await getRagInstance(modelId, embeddingFunction, workspace);
     const results = await rag.search(query, { topK, n });

package/dist/server/bare/rag-hyperdb/rag-workspace-manager.js

@@ -7,6 +7,7 @@ import { RAGWorkspaceModelMismatchError, RAGWorkspaceNotOpenError, } from "../..
 import { validateAndJoinPath } from "../../utils/path-security.js";
 import { createStreamLogger, getServerLogger, RAG_NAMESPACE, } from "../../../logging/index.js";
 import { cancelAllRagOperations } from "./rag-operation-manager.js";
+import { registerCorestore, unregisterCorestore, } from "../runtime-lifecycle.js";
 const logger = getServerLogger();
 const ragWorkspaces = new Map();
 export const DEFAULT_WORKSPACE = "default";
@@ -39,6 +40,10 @@ async function getOrCreateWorkspaceEntry(workspace) {
         dbName: key,
     });
     await dbAdapter.ready();
+    registerCorestore(corestore, {
+        label: `rag-workspace:${key}`,
+        createdAt: Date.now(),
+    });
     const entry = {
         corestore,
         dbAdapter,
@@ -81,6 +86,7 @@ export async function closeRagInstance(workspace) {
     }
     await entry.dbAdapter.close();
     await entry.corestore.close();
+    unregisterCorestore(entry.corestore);
     ragWorkspaces.delete(key);
 }
 let isCleaningUp = false;
@@ -96,6 +102,7 @@ export async function closeAllRagInstances() {
             }
             await entry.dbAdapter.close();
             await entry.corestore.close();
+            unregisterCorestore(entry.corestore);
             ragWorkspaces.delete(key);
         });
         await Promise.all(closures);

package/dist/server/bare/registry/model-config-utils.js

@@ -2,6 +2,7 @@ import { ModelType, } from "../../../schemas/index.js";
 import { llmConfigSchema, embedConfigSchema } from "../../../schemas/llamacpp-config.js";
 import { whisperConfigSchema, parakeetRuntimeConfigSchema, } from "../../../schemas/transcription-config.js";
 import { ocrConfigSchema } from "../../../schemas/ocr.js";
+import { sdcppConfigSchema } from "../../../schemas/sdcpp-config.js";
 export const CANONICAL_TO_ALIAS = {
     [ModelType.llamacppCompletion]: "llm",
     [ModelType.llamacppEmbedding]: "embeddings",
@@ -10,6 +11,7 @@ export const CANONICAL_TO_ALIAS = {
     [ModelType.nmtcppTranslation]: "nmt",
     [ModelType.onnxTts]: "tts",
     [ModelType.onnxOcr]: "ocr",
+    [ModelType.sdcppGeneration]: "diffusion",
 };
 export const MODEL_CONFIG_SCHEMAS = {
     [ModelType.llamacppCompletion]: llmConfigSchema,
@@ -17,6 +19,7 @@ export const MODEL_CONFIG_SCHEMAS = {
     [ModelType.whispercppTranscription]: whisperConfigSchema,
     [ModelType.parakeetTranscription]: parakeetRuntimeConfigSchema.passthrough(),
     [ModelType.onnxOcr]: ocrConfigSchema,
+    [ModelType.sdcppGeneration]: sdcppConfigSchema,
 };
 // Ordered general → specific (later patterns override earlier)
 export const BUILTIN_DEVICE_PATTERNS = [

package/dist/server/bare/registry/model-registry.d.ts

@@ -21,7 +21,7 @@ interface LocalOptions {
     config: unknown;
     modelType: CanonicalModelType;
     name?: string | undefined;
-    loader: FilesystemDL;
+    loader?: FilesystemDL;
 }
 export interface ModelEntry {
     id: string;
@@ -34,7 +34,7 @@ export declare function registerModel(id: string, options: {
     path: string;
     config: unknown;
     modelType: CanonicalModelType;
-    loader: FilesystemDL;
+    loader?: FilesystemDL;
     name?: string | undefined;
 } | {
     topic: string;

package/dist/server/bare/registry/model-registry.js

@@ -32,7 +32,7 @@ export function registerModel(id, options) {
                 loadedAt: new Date(),
                 config: options.config,
                 modelType: options.modelType,
-                loader: options.loader,
+                ...(options.loader && { loader: options.loader }),
                 name: options.name,
             },
         });