@qvac/sdk 0.9.2 → 0.10.1

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

@@ -45,6 +45,7 @@ export declare const parakeetPlugin: {
             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";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -55,7 +56,6 @@ export declare const parakeetPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -75,6 +75,7 @@ export declare const parakeetPlugin: {
             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";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -85,7 +86,6 @@ export declare const parakeetPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -105,6 +105,7 @@ export declare const parakeetPlugin: {
             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";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -115,7 +116,6 @@ export declare const parakeetPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -135,6 +135,7 @@ export declare const parakeetPlugin: {
             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";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -145,7 +146,6 @@ export declare const parakeetPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -165,6 +165,7 @@ export declare const parakeetPlugin: {
             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";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -175,7 +176,6 @@ export declare const parakeetPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -195,6 +195,7 @@ export declare const parakeetPlugin: {
             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";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -205,7 +206,6 @@ export declare const parakeetPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -225,6 +225,7 @@ export declare const parakeetPlugin: {
             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";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -235,7 +236,6 @@ export declare const parakeetPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -251,6 +251,7 @@ export declare const parakeetPlugin: {
         transcribe: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
             modelId: import("zod").ZodString;
             prompt: import("zod").ZodOptional<import("zod").ZodString>;
+            metadata: import("zod").ZodOptional<import("zod").ZodBoolean>;
             audioChunk: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
                 type: import("zod").ZodLiteral<"base64">;
                 value: import("zod").ZodString;
@@ -275,6 +276,13 @@ export declare const parakeetPlugin: {
                 melSpecTime: import("zod").ZodOptional<import("zod").ZodNumber>;
             }, import("zod/v4/core").$strip>>;
             error: import("zod").ZodOptional<import("zod").ZodString>;
+            segment: import("zod").ZodOptional<import("zod").ZodObject<{
+                text: import("zod").ZodString;
+                startMs: import("zod").ZodNumber;
+                endMs: import("zod").ZodNumber;
+                append: import("zod").ZodBoolean;
+                id: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
             type: import("zod").ZodLiteral<"transcribe">;
         }, import("zod/v4/core").$strip>>;
     };

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

@@ -2,9 +2,7 @@ import parakeetAddonLogging from "@qvac/transcription-parakeet/addonLogging.js";
 import TranscriptionParakeet, {} from "@qvac/transcription-parakeet";
 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 { ModelLoadFailedError, ParakeetArtifactsRequiredError, TranscriptionFailedError, } from "../../../../utils/errors-server.js";
 import { transcribe } from "../../ops/transcribe.js";
 import { attachModelExecutionMs } from "../../../../profiling/model-execution.js";
 async function resolveTdtConfig(cfg, ctx) {
@@ -76,8 +74,6 @@ function createParakeetModel(params, primaryFileKey) {
     if (!primaryPath) {
         throw new ModelLoadFailedError(`Parakeet ${modelType} requires a model source`);
     }
-    const { dirPath } = parseModelPath(primaryPath);
-    const loader = new FilesystemDL({ dirPath });
     const logger = createStreamLogger(params.modelId, ModelType.parakeetTranscription);
     registerAddonLogger(params.modelId, ModelType.parakeetTranscription, logger);
     const files = {
@@ -101,7 +97,7 @@ function createParakeetModel(params, primaryFileKey) {
         config: addonConfig,
         logger,
     });
-    return { model, loader };
+    return { model };
 }
 export const parakeetPlugin = definePlugin({
     modelType: ModelType.parakeetTranscription,
@@ -131,6 +127,9 @@ export const parakeetPlugin = definePlugin({
             responseSchema: transcribeResponseSchema,
             streaming: true,
             handler: async function* (request) {
+                if (request.metadata === true) {
+                    throw new TranscriptionFailedError(`Parakeet transcription does not support metadata: true; only the whisper engine emits per-segment metadata. Use a whisper model to receive segments.`);
+                }
                 const stream = transcribe({
                     modelId: request.modelId,
                     audioChunk: request.audioChunk,

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

@@ -1,6 +1,9 @@
 import { getModel } from "../../../registry/model-registry.js";
 export async function* diffusion(request) {
     const model = getModel(request.modelId);
+    const init_image = request.init_image
+        ? Buffer.from(request.init_image, "base64")
+        : undefined;
     const response = await model.run({
         prompt: request.prompt,
         negative_prompt: request.negative_prompt,
@@ -8,6 +11,7 @@ export async function* diffusion(request) {
         height: request.height,
         steps: request.steps,
         cfg_scale: request.cfg_scale,
+        img_cfg_scale: request.img_cfg_scale ?? -1,
         guidance: request.guidance,
         sampling_method: request.sampling_method,
         scheduler: request.scheduler,
@@ -15,6 +19,8 @@ export async function* diffusion(request) {
         batch_count: request.batch_count,
         vae_tiling: request.vae_tiling,
         cache_preset: request.cache_preset,
+        init_image,
+        strength: request.strength,
     });
     let outputIndex = 0;
     for await (const chunk of response.iterate()) {

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

@@ -62,6 +62,7 @@ export declare const diffusionPlugin: {
             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";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -72,7 +73,6 @@ export declare const diffusionPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -92,6 +92,7 @@ export declare const diffusionPlugin: {
             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";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -102,7 +103,6 @@ export declare const diffusionPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -122,6 +122,7 @@ export declare const diffusionPlugin: {
             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";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -132,7 +133,6 @@ export declare const diffusionPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -152,6 +152,7 @@ export declare const diffusionPlugin: {
             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";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -162,7 +163,6 @@ export declare const diffusionPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -182,6 +182,7 @@ export declare const diffusionPlugin: {
             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";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -192,7 +193,6 @@ export declare const diffusionPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -212,6 +212,7 @@ export declare const diffusionPlugin: {
             height: import("zod").ZodOptional<import("zod").ZodNumber>;
             steps: import("zod").ZodOptional<import("zod").ZodNumber>;
             cfg_scale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            img_cfg_scale: import("zod").ZodDefault<import("zod").ZodNumber>;
             guidance: import("zod").ZodOptional<import("zod").ZodNumber>;
             sampling_method: import("zod").ZodOptional<import("zod").ZodEnum<{
                 euler: "euler";
@@ -246,6 +247,8 @@ export declare const diffusionPlugin: {
             batch_count: import("zod").ZodOptional<import("zod").ZodNumber>;
             vae_tiling: import("zod").ZodOptional<import("zod").ZodBoolean>;
             cache_preset: import("zod").ZodOptional<import("zod").ZodString>;
+            init_image: import("zod").ZodOptional<import("zod").ZodString>;
+            strength: import("zod").ZodOptional<import("zod").ZodNumber>;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             type: import("zod").ZodLiteral<"diffusionStream">;
             step: import("zod").ZodOptional<import("zod").ZodNumber>;

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

@@ -2,7 +2,6 @@ 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,
@@ -38,22 +37,23 @@ export const diffusionPlugin = definePlugin({
     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,
+        const files = {
+            model: modelPath,
+            ...(artifacts?.["clipLModelPath"] && { clipL: artifacts["clipLModelPath"] }),
+            ...(artifacts?.["clipGModelPath"] && { clipG: artifacts["clipGModelPath"] }),
+            ...(artifacts?.["t5XxlModelPath"] && { t5Xxl: artifacts["t5XxlModelPath"] }),
+            ...(artifacts?.["llmModelPath"] && { llm: artifacts["llmModelPath"] }),
+            ...(artifacts?.["vaeModelPath"] && { vae: artifacts["vaeModelPath"] }),
+        };
+        const model = new ImgStableDiffusion({
+            files,
+            config: config,
             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 };
+        });
+        return { model };
     },
     handlers: {
         diffusionStream: defineHandler({

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

@@ -75,6 +75,7 @@ export declare const whisperPlugin: {
             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";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -85,7 +86,6 @@ export declare const whisperPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -216,6 +216,7 @@ export declare const whisperPlugin: {
         transcribe: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
             modelId: import("zod").ZodString;
             prompt: import("zod").ZodOptional<import("zod").ZodString>;
+            metadata: import("zod").ZodOptional<import("zod").ZodBoolean>;
             audioChunk: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
                 type: import("zod").ZodLiteral<"base64">;
                 value: import("zod").ZodString;
@@ -240,11 +241,19 @@ export declare const whisperPlugin: {
                 melSpecTime: import("zod").ZodOptional<import("zod").ZodNumber>;
             }, import("zod/v4/core").$strip>>;
             error: import("zod").ZodOptional<import("zod").ZodString>;
+            segment: import("zod").ZodOptional<import("zod").ZodObject<{
+                text: import("zod").ZodString;
+                startMs: import("zod").ZodNumber;
+                endMs: import("zod").ZodNumber;
+                append: import("zod").ZodBoolean;
+                id: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
             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>;
+            metadata: import("zod").ZodOptional<import("zod").ZodBoolean>;
             type: import("zod").ZodLiteral<"transcribeStream">;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             text: import("zod").ZodOptional<import("zod").ZodString>;
@@ -262,6 +271,13 @@ export declare const whisperPlugin: {
                 melSpecTime: import("zod").ZodOptional<import("zod").ZodNumber>;
             }, import("zod/v4/core").$strip>>;
             error: import("zod").ZodOptional<import("zod").ZodString>;
+            segment: import("zod").ZodOptional<import("zod").ZodObject<{
+                text: import("zod").ZodString;
+                startMs: import("zod").ZodNumber;
+                endMs: import("zod").ZodNumber;
+                append: import("zod").ZodBoolean;
+                id: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
             type: import("zod").ZodLiteral<"transcribeStream">;
         }, import("zod/v4/core").$strip>>;
     };

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

@@ -24,7 +24,7 @@ function createWhisperModel(modelId, modelPath, whisperConfig, vadModelPath) {
         ...(miscConfig && { miscConfig }),
     };
     const model = new TranscriptionWhispercpp(args, config);
-    return { model, loader: null };
+    return { model };
 }
 export const whisperPlugin = definePlugin({
     modelType: ModelType.whispercppTranscription,
@@ -44,8 +44,8 @@ export const whisperPlugin = definePlugin({
     },
     createModel(params) {
         const whisperConfig = (params.modelConfig ?? {});
-        const { model, loader } = createWhisperModel(params.modelId, params.modelPath, whisperConfig, params.artifacts?.["vadModelPath"]);
-        return { model, loader };
+        const { model } = createWhisperModel(params.modelId, params.modelPath, whisperConfig, params.artifacts?.["vadModelPath"]);
+        return { model };
     },
     handlers: {
         transcribe: defineHandler({
@@ -53,18 +53,31 @@ export const whisperPlugin = definePlugin({
             responseSchema: transcribeResponseSchema,
             streaming: true,
             handler: async function* (request) {
-                const stream = transcribe({
-                    modelId: request.modelId,
-                    audioChunk: request.audioChunk,
-                    prompt: request.prompt,
-                });
+                const metadata = request.metadata === true;
+                const stream = metadata
+                    ? transcribe({
+                        modelId: request.modelId,
+                        audioChunk: request.audioChunk,
+                        prompt: request.prompt,
+                        metadata: true,
+                    })
+                    : 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,
-                        };
+                        yield metadata
+                            ? {
+                                type: "transcribe",
+                                segment: result.value,
+                            }
+                            : {
+                                type: "transcribe",
+                                text: result.value,
+                            };
                         result = await stream.next();
                     }
                     const { modelExecutionMs, stats } = result.value;
@@ -86,11 +99,21 @@ export const whisperPlugin = definePlugin({
             streaming: true,
             duplex: true,
             handler: async function* (request, inputStream) {
-                for await (const text of transcribeStream(request.modelId, inputStream, request.prompt)) {
-                    yield {
-                        type: "transcribeStream",
-                        text,
-                    };
+                if (request.metadata === true) {
+                    for await (const segment of transcribeStream(request.modelId, inputStream, request.prompt, true)) {
+                        yield {
+                            type: "transcribeStream",
+                            segment,
+                        };
+                    }
+                }
+                else {
+                    for await (const text of transcribeStream(request.modelId, inputStream, request.prompt)) {
+                        yield {
+                            type: "transcribeStream",
+                            text,
+                        };
+                    }
                 }
                 yield {
                     type: "transcribeStream",

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

@@ -1,6 +1,6 @@
 import fs from "bare-fs";
 import path from "bare-path";
-import { getEnv } from "../../env.js";
+import { getQvacPath } from "../../utils/qvac-paths.js";
 import { CacheDirNotAbsoluteError, CacheDirNotWritableError, ConfigAlreadySetError, } from "../../../utils/errors-server.js";
 import { getServerLogger, setGlobalConsoleOutput, setGlobalLogLevel, } from "../../../logging/index.js";
 const logger = getServerLogger();
@@ -10,6 +10,8 @@ const configRegistry = {
     loggerLevel: undefined,
     loggerConsoleOutput: undefined,
     httpDownloadConcurrency: undefined,
+    registryDownloadMaxRetries: undefined,
+    registryStreamTimeoutMs: undefined,
     deviceDefaults: undefined,
 };
 let configIsSet = false;
@@ -63,6 +65,16 @@ export function setSDKConfig(config) {
         configRegistry.httpDownloadConcurrency = config.httpDownloadConcurrency;
         logger.info(`HTTP download concurrency set to: ${config.httpDownloadConcurrency}`);
     }
+    if (config.registryDownloadMaxRetries !== undefined &&
+        config.registryDownloadMaxRetries !== null) {
+        configRegistry.registryDownloadMaxRetries = config.registryDownloadMaxRetries;
+        logger.info(`✅ Registry download max retries set to: ${config.registryDownloadMaxRetries}`);
+    }
+    if (config.registryStreamTimeoutMs !== undefined &&
+        config.registryStreamTimeoutMs !== null) {
+        configRegistry.registryStreamTimeoutMs = config.registryStreamTimeoutMs;
+        logger.info(`✅ Registry stream timeout set to: ${config.registryStreamTimeoutMs}ms`);
+    }
     if (config.deviceDefaults !== undefined && config.deviceDefaults !== null) {
         configRegistry.deviceDefaults = config.deviceDefaults;
         logger.info(`✅ Device defaults configured: ${config.deviceDefaults.length} pattern(s)`);
@@ -74,8 +86,7 @@ export function getSDKConfig() {
     return { ...configRegistry };
 }
 function getDefaultCacheDir() {
-    const homeDir = getEnv().HOME_DIR;
-    return path.join(homeDir, ".qvac", "models");
+    return getQvacPath("models");
 }
 export function getConfiguredCacheDir() {
     return configRegistry.cacheDirectory || getDefaultCacheDir();

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

@@ -1,4 +1,3 @@
-import type FilesystemDL from "@qvac/dl-filesystem";
 import type { CanonicalModelType } from "../../../schemas/index";
 import type BaseInference from "@qvac/infer-base";
 interface AddonInterface {
@@ -9,7 +8,6 @@ export type AnyModel = Omit<BaseInference, "addon"> & {
     addon?: AddonInterface;
 };
 interface DelegateOptions {
-    topic: string;
     providerPublicKey: string;
     timeout?: number | undefined;
     healthCheckTimeout?: number | undefined;
@@ -21,23 +19,23 @@ interface LocalOptions {
     config: unknown;
     modelType: CanonicalModelType;
     name?: string | undefined;
-    loader?: FilesystemDL;
 }
-export interface ModelEntry {
+export type ModelEntry = {
     id: string;
-    isDelegated: boolean;
-    local?: LocalOptions;
-    delegated?: DelegateOptions;
-}
+    isDelegated: true;
+    delegated: DelegateOptions;
+} | {
+    id: string;
+    isDelegated: false;
+    local: LocalOptions;
+};
 export declare function registerModel(id: string, options: {
     model: AnyModel;
     path: string;
     config: unknown;
     modelType: CanonicalModelType;
-    loader?: FilesystemDL;
     name?: string | undefined;
 } | {
-    topic: string;
     providerPublicKey: string;
     timeout?: number;
     healthCheckTimeout?: number;

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

@@ -7,20 +7,19 @@ export function registerModel(id, options) {
     if (modelRegistry.has(id)) {
         throw new ModelAlreadyRegisteredError(id);
     }
-    const isDelegated = "topic" in options && "providerPublicKey" in options;
+    const isDelegated = "providerPublicKey" in options;
     if (isDelegated) {
-        const { topic, providerPublicKey, timeout, healthCheckTimeout } = options;
+        const { providerPublicKey, timeout, healthCheckTimeout } = options;
         modelRegistry.set(id, {
             id,
             isDelegated: true,
             delegated: {
-                topic,
                 providerPublicKey,
                 timeout,
                 healthCheckTimeout,
             },
         });
-        logger.info(`Delegated model registered: ${id} -> topic: ${topic}, provider: ${providerPublicKey}, timeout: ${timeout}ms`);
+        logger.info(`Delegated model registered: ${id} -> provider: ${providerPublicKey}, timeout: ${timeout}ms`);
     }
     else {
         modelRegistry.set(id, {
@@ -32,7 +31,6 @@ export function registerModel(id, options) {
                 loadedAt: new Date(),
                 config: options.config,
                 modelType: options.modelType,
-                ...(options.loader && { loader: options.loader }),
                 name: options.name,
             },
         });
@@ -48,7 +46,7 @@ export function getModel(id) {
     if (!entry) {
         throw new ModelNotFoundError(id);
     }
-    if (!entry.local) {
+    if (entry.isDelegated) {
         throw new ModelIsDelegatedError(id);
     }
     return entry.local.model;
@@ -70,7 +68,7 @@ export function getAllModelIds() {
 }
 export function getModelInfo(id) {
     const entry = modelRegistry.get(id);
-    if (!entry || !entry.local) {
+    if (!entry || entry.isDelegated) {
         return null;
     }
     const result = {
@@ -86,7 +84,7 @@ export function getModelInfo(id) {
 }
 export function getModelConfig(id) {
     const entry = modelRegistry.get(id);
-    if (!entry || !entry.local) {
+    if (!entry || entry.isDelegated) {
         throw new ModelNotFoundError(id);
     }
     return entry.local.config;
@@ -96,7 +94,7 @@ export function updateModelConfig(id, config) {
     if (!entry) {
         throw new ModelNotFoundError(id);
     }
-    if (!entry.local) {
+    if (entry.isDelegated) {
         throw new ModelIsDelegatedError(id);
     }
     entry.local.config = config;
@@ -115,9 +113,16 @@ export async function unloadAllModels() {
     const modelIds = getAllModelIds();
     for (const modelId of modelIds) {
         const entry = modelRegistry.get(modelId);
-        if (entry?.local?.model && entry.local.model.unload) {
-            await entry.local.model.unload();
-            logger.debug(`Model unloaded: ${modelId}`);
+        try {
+            if (entry && !entry.isDelegated) {
+                if (entry.local.model.unload) {
+                    await entry.local.model.unload();
+                }
+                logger.debug(`Model unloaded: ${modelId}`);
+            }
+        }
+        catch (error) {
+            logger.error(`Error unloading model ${modelId}:`, error instanceof Error ? error.message : String(error));
         }
         modelRegistry.delete(modelId);
     }