@qvac/sdk 0.11.0 → 0.12.0

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

@@ -0,0 +1,189 @@
+import ttsAddonLogging from "@qvac/tts-ggml/addonLogging.js";
+import TTSGgml from "@qvac/tts-ggml";
+import { definePlugin, defineHandler, defineDuplexHandler, ttsRequestSchema, ttsResponseSchema, textToSpeechStreamRequestSchema, textToSpeechStreamResponseSchema, ModelType, ttsConfigSchema, ADDON_TTS, LEGACY_TTS_ONNX_MODEL_CONFIG_FIELDS, } from "../../../../schemas/index.js";
+import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
+import { TtsArtifactsRequiredError, LegacyTtsModelDeprecatedError, } from "../../../../utils/errors-server.js";
+import { textToSpeech } from "./ops/text-to-speech.js";
+import { textToSpeechStream } from "./ops/text-to-speech-stream.js";
+import { attachModelExecutionMs } from "../../../../profiling/model-execution.js";
+function rejectLegacyOnnxFields(cfg) {
+    const record = cfg;
+    const legacyFields = LEGACY_TTS_ONNX_MODEL_CONFIG_FIELDS.filter((name) => record[name] !== undefined);
+    if (legacyFields.length > 0) {
+        throw new LegacyTtsModelDeprecatedError(legacyFields);
+    }
+}
+async function resolveChatterboxConfig(config, ctx) {
+    rejectLegacyOnnxFields(config);
+    const { s3genModelSrc, referenceAudioSrc, ...runtime } = config;
+    if (!s3genModelSrc) {
+        throw new TtsArtifactsRequiredError();
+    }
+    const resolve = ctx.resolveModelPath;
+    const [s3genPath, referenceAudioPath] = await Promise.all([
+        resolve(s3genModelSrc),
+        referenceAudioSrc ? resolve(referenceAudioSrc) : Promise.resolve(undefined),
+    ]);
+    return {
+        config: runtime,
+        artifacts: {
+            s3genPath,
+            ...(referenceAudioPath ? { referenceAudioPath } : {}),
+        },
+    };
+}
+function resolveSupertonicConfig(config) {
+    rejectLegacyOnnxFields(config);
+    return Promise.resolve({ config });
+}
+function createChatterboxModel(modelId, config, params, artifacts) {
+    const t3Model = params.modelPath;
+    const s3genModel = artifacts["s3genPath"];
+    const referenceAudioPath = artifacts["referenceAudioPath"];
+    if (!t3Model || !s3genModel) {
+        throw new TtsArtifactsRequiredError();
+    }
+    const logger = createStreamLogger(modelId, ModelType.ttsGgml);
+    registerAddonLogger(modelId, ModelType.ttsGgml, logger);
+    const model = new TTSGgml({
+        engine: TTSGgml.ENGINE_CHATTERBOX,
+        files: { t3Model, s3genModel },
+        ...(referenceAudioPath ? { referenceAudio: referenceAudioPath } : {}),
+        config: {
+            language: config.language ?? "en",
+            ...(config.useGPU !== undefined ? { useGPU: config.useGPU } : {}),
+        },
+        logger,
+        opts: { stats: true },
+        exclusiveRun: true,
+    });
+    return { model };
+}
+function createSupertonicModel(modelId, config, params) {
+    const supertonicModel = params.modelPath;
+    if (!supertonicModel) {
+        throw new TtsArtifactsRequiredError();
+    }
+    const logger = createStreamLogger(modelId, ModelType.ttsGgml);
+    registerAddonLogger(modelId, ModelType.ttsGgml, logger);
+    const model = new TTSGgml({
+        engine: TTSGgml.ENGINE_SUPERTONIC,
+        files: { supertonicModel },
+        voice: config.voice ?? "F1",
+        ...(config.ttsSpeed !== undefined ? { speed: config.ttsSpeed } : {}),
+        ...(config.ttsNumInferenceSteps !== undefined
+            ? { numInferenceSteps: config.ttsNumInferenceSteps }
+            : {}),
+        config: {
+            language: config.language ?? "en",
+            useGPU: config.useGPU ?? false,
+        },
+        logger,
+        opts: { stats: true },
+        exclusiveRun: true,
+    });
+    return { model };
+}
+export const ttsPlugin = definePlugin({
+    modelType: ModelType.ttsGgml,
+    displayName: "TTS (GGML)",
+    addonPackage: ADDON_TTS,
+    loadConfigSchema: ttsConfigSchema,
+    async resolveConfig(cfg, ctx) {
+        const { ttsEngine } = cfg;
+        // Same default as the former onnx-tts plugin: omitting `ttsEngine` → Chatterbox.
+        if (ttsEngine === "supertonic") {
+            return resolveSupertonicConfig(cfg);
+        }
+        return resolveChatterboxConfig(cfg, ctx);
+    },
+    createModel(params) {
+        const config = (params.modelConfig ?? {});
+        const artifacts = params.artifacts ?? {};
+        if (config.ttsEngine === "supertonic") {
+            return createSupertonicModel(params.modelId, config, params);
+        }
+        return createChatterboxModel(params.modelId, config, params, artifacts);
+    },
+    handlers: {
+        textToSpeech: defineHandler({
+            requestSchema: ttsRequestSchema,
+            responseSchema: ttsResponseSchema,
+            streaming: true,
+            cancel: { scope: "model", hard: true },
+            handler: async function* (request) {
+                const stream = textToSpeech(request);
+                try {
+                    let result = await stream.next();
+                    while (!result.done) {
+                        yield {
+                            type: "textToSpeech",
+                            buffer: result.value.buffer,
+                            done: false,
+                            ...(result.value.chunkIndex !== undefined
+                                ? { chunkIndex: result.value.chunkIndex }
+                                : {}),
+                            ...(typeof result.value.sentenceChunk === "string" &&
+                                result.value.sentenceChunk.length > 0
+                                ? { sentenceChunk: result.value.sentenceChunk }
+                                : {}),
+                        };
+                        result = await stream.next();
+                    }
+                    const { modelExecutionMs, stats } = result.value;
+                    yield attachModelExecutionMs({
+                        type: "textToSpeech",
+                        buffer: [],
+                        done: true,
+                        ...(stats && { stats }),
+                    }, modelExecutionMs);
+                }
+                finally {
+                    await stream.return?.(undefined);
+                }
+            },
+        }),
+        textToSpeechStream: defineDuplexHandler({
+            requestSchema: textToSpeechStreamRequestSchema,
+            responseSchema: textToSpeechStreamResponseSchema,
+            streaming: true,
+            duplex: true,
+            cancel: { scope: "model", hard: true },
+            handler: async function* (request, inputStream) {
+                const stream = textToSpeechStream(request, inputStream);
+                try {
+                    let result = await stream.next();
+                    while (!result.done) {
+                        yield {
+                            type: "textToSpeechStream",
+                            buffer: result.value.buffer,
+                            done: false,
+                            ...(result.value.chunkIndex !== undefined
+                                ? { chunkIndex: result.value.chunkIndex }
+                                : {}),
+                            ...(typeof result.value.sentenceChunk === "string" &&
+                                result.value.sentenceChunk.length > 0
+                                ? { sentenceChunk: result.value.sentenceChunk }
+                                : {}),
+                        };
+                        result = await stream.next();
+                    }
+                    const { modelExecutionMs, stats } = result.value;
+                    yield attachModelExecutionMs({
+                        type: "textToSpeechStream",
+                        buffer: [],
+                        done: true,
+                        ...(stats && { stats }),
+                    }, modelExecutionMs);
+                }
+                finally {
+                    await stream.return?.(undefined);
+                }
+            },
+        }),
+    },
+    logging: {
+        module: ttsAddonLogging,
+        namespace: ModelType.ttsGgml,
+    },
+});

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

@@ -79,18 +79,23 @@ export declare const whisperPlugin: {
                 diffusion: "diffusion";
                 tts: "tts";
                 ocr: "ocr";
+                vla: "vla";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
                 "nmtcpp-translation": "nmtcpp-translation";
                 "onnx-tts": "onnx-tts";
+                "tts-ggml": "tts-ggml";
                 "parakeet-transcription": "parakeet-transcription";
                 "onnx-ocr": "onnx-ocr";
                 "sdcpp-generation": "sdcpp-generation";
+                "ggml-vla": "ggml-vla";
+                "ggml-classification": "ggml-classification";
                 llm: "llm";
                 whisper: "whisper";
                 nmt: "nmt";
                 parakeet: "parakeet";
+                classification: "classification";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
     }, import("zod/v4/core").$strip>;
@@ -253,9 +258,12 @@ export declare const whisperPlugin: {
                 speaking: import("zod").ZodBoolean;
                 probability: import("zod").ZodNumber;
             }, import("zod/v4/core").$strip>>;
-            endOfTurn: import("zod").ZodOptional<import("zod").ZodObject<{
+            endOfTurn: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                source: import("zod").ZodLiteral<"whisper">;
                 silenceDurationMs: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                source: import("zod").ZodLiteral<"parakeet">;
+            }, import("zod/v4/core").$strip>], "source">>>;
             type: import("zod").ZodLiteral<"transcribe">;
         }, import("zod/v4/core").$strip>>;
         transcribeStream: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
@@ -266,6 +274,20 @@ export declare const whisperPlugin: {
             emitVadEvents: import("zod").ZodOptional<import("zod").ZodBoolean>;
             endOfTurnSilenceMs: import("zod").ZodOptional<import("zod").ZodNumber>;
             vadRunIntervalMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+            parakeetStreamingConfig: import("zod").ZodOptional<import("zod").ZodObject<{
+                chunkMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                historyMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                leftContextMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                rightLookaheadMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                emitPartials: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                emitEnergyVad: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                spkCacheEnable: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                spkCacheLen: import("zod").ZodOptional<import("zod").ZodNumber>;
+                fifoLen: import("zod").ZodOptional<import("zod").ZodNumber>;
+                chunkLeftContextMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                chunkRightContextMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                spkCacheUpdatePeriod: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>>;
             requestId: import("zod").ZodOptional<import("zod").ZodString>;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             text: import("zod").ZodOptional<import("zod").ZodString>;
@@ -294,9 +316,12 @@ export declare const whisperPlugin: {
                 speaking: import("zod").ZodBoolean;
                 probability: import("zod").ZodNumber;
             }, import("zod/v4/core").$strip>>;
-            endOfTurn: import("zod").ZodOptional<import("zod").ZodObject<{
+            endOfTurn: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                source: import("zod").ZodLiteral<"whisper">;
                 silenceDurationMs: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                source: import("zod").ZodLiteral<"parakeet">;
+            }, import("zod/v4/core").$strip>], "source">>>;
             type: import("zod").ZodLiteral<"transcribeStream">;
         }, import("zod/v4/core").$strip>>;
     };

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

@@ -133,9 +133,20 @@ export const whisperPlugin = definePlugin({
                             continue;
                         }
                         if (value.type === "endOfTurn") {
+                            // Whisper addon emits legacy `{ type, silenceDurationMs }` frames
+                            // without `source`. Parakeet must never surface here.
+                            if (value.source === "parakeet") {
+                                continue;
+                            }
+                            if (typeof value.silenceDurationMs !== "number") {
+                                continue;
+                            }
                             yield {
                                 type: "transcribeStream",
-                                endOfTurn: { silenceDurationMs: value.silenceDurationMs },
+                                endOfTurn: {
+                                    source: "whisper",
+                                    silenceDurationMs: value.silenceDurationMs,
+                                },
                             };
                             continue;
                         }

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

@@ -3,6 +3,8 @@ import { llmConfigSchema, embedConfigSchema } from "../../../schemas/llamacpp-co
 import { whisperConfigSchema, parakeetRuntimeConfigSchema, } from "../../../schemas/transcription-config.js";
 import { ocrConfigSchema } from "../../../schemas/ocr.js";
 import { sdcppConfigSchema } from "../../../schemas/sdcpp-config.js";
+import { vlaConfigSchema } from "../../../schemas/vla.js";
+import { classificationConfigSchema } from "../../../schemas/classification.js";
 export const CANONICAL_TO_ALIAS = {
     [ModelType.llamacppCompletion]: "llm",
     [ModelType.llamacppEmbedding]: "embeddings",
@@ -10,8 +12,11 @@ export const CANONICAL_TO_ALIAS = {
     [ModelType.parakeetTranscription]: "parakeet",
     [ModelType.nmtcppTranslation]: "nmt",
     [ModelType.onnxTts]: "tts",
+    [ModelType.ttsGgml]: "tts",
     [ModelType.onnxOcr]: "ocr",
     [ModelType.sdcppGeneration]: "diffusion",
+    [ModelType.ggmlVla]: "vla",
+    [ModelType.ggmlClassification]: "classification",
 };
 export const MODEL_CONFIG_SCHEMAS = {
     [ModelType.llamacppCompletion]: llmConfigSchema,
@@ -20,6 +25,8 @@ export const MODEL_CONFIG_SCHEMAS = {
     [ModelType.parakeetTranscription]: parakeetRuntimeConfigSchema.passthrough(),
     [ModelType.onnxOcr]: ocrConfigSchema,
     [ModelType.sdcppGeneration]: sdcppConfigSchema,
+    [ModelType.ggmlVla]: vlaConfigSchema,
+    [ModelType.ggmlClassification]: classificationConfigSchema,
 };
 // Ordered general → specific (later patterns override earlier)
 export const BUILTIN_DEVICE_PATTERNS = [

package/dist/server/bare/runtime/request-context.d.ts

@@ -9,7 +9,7 @@ import type { DisposableScope } from "./disposable-scope";
  * The set is intentionally open-coded — adding a new kind is a one-line
  * change and the union surfaces in editor autocomplete at every call site.
  */
-export type RequestKind = "completion" | "embeddings" | "transcribe" | "translate" | "diffusion" | "tts" | "ocr" | "finetune" | "loadModel" | "downloadAsset" | "rag";
+export type RequestKind = "completion" | "embeddings" | "transcribe" | "translate" | "diffusion" | "tts" | "ocr" | "vla" | "finetune" | "loadModel" | "downloadAsset" | "rag";
 /**
  * Lifecycle states a request transitions through. A new context starts in
  * `"running"`. `cancel(...)` flips it to `"cancelling"` and aborts the

package/dist/server/bare/runtime-lifecycle.js

@@ -78,17 +78,17 @@ export async function suspendRuntime() {
         return suspendRuntime();
     }
     state = "suspending";
-    logger.info(`⏸️ Suspending runtime (${swarms.size} swarms, ${stores.size} stores)`);
+    logger.info(`⏸️ Suspending runtime (${stores.size} stores, ${swarms.size} swarms)`);
     transitionPromise = (async () => {
         const swarmSnapshot = Array.from(swarms.entries());
         const storeSnapshot = Array.from(stores.entries());
+        await runPhase(storeSnapshot, stores, async (store) => {
+            await store.suspend();
+        }, "suspend-store");
         await runPhase(swarmSnapshot, swarms, async (swarm) => {
             if (!swarm.suspended)
                 await swarm.suspend();
         }, "suspend-swarm");
-        await runPhase(storeSnapshot, stores, async (store) => {
-            await store.suspend();
-        }, "suspend-store");
     })()
         .then(() => {
         state = "suspended";
@@ -116,16 +116,16 @@ export async function resumeRuntime() {
         return resumeRuntime();
     }
     state = "resuming";
-    logger.info(`▶️ Resuming runtime (${stores.size} stores, ${swarms.size} swarms)`);
+    logger.info(`▶️ Resuming runtime (${swarms.size} swarms, ${stores.size} stores)`);
     transitionPromise = (async () => {
-        const storeSnapshot = Array.from(stores.entries());
         const swarmSnapshot = Array.from(swarms.entries());
-        await runPhase(storeSnapshot, stores, async (store) => {
-            await store.resume();
-        }, "resume-store");
+        const storeSnapshot = Array.from(stores.entries());
         await runPhase(swarmSnapshot, swarms, async (swarm) => {
             await swarm.resume();
         }, "resume-swarm");
+        await runPhase(storeSnapshot, stores, async (store) => {
+            await store.resume();
+        }, "resume-store");
     })()
         .then(() => {
         state = "active";

package/dist/server/bare/types/addon-responses.d.ts

@@ -2,6 +2,7 @@ export interface LlmStats {
     TTFT?: number;
     TPS?: number;
     CacheTokens?: number;
+    promptTokens?: number;
     generatedTokens?: number;
     backendDevice?: "cpu" | "gpu";
 }

package/dist/server/env.js

@@ -11,7 +11,10 @@ let validatedEnv = null;
  * Returns whether RPC config was parsed from arguments.
  */
 export function initEnv() {
-    const defaultHomeDir = process.env["HOME"] ??
+    const defaultHomeDir = 
+    // Snap's HOME can be revision-scoped; SNAP_USER_COMMON is stable.
+    process.env["SNAP_USER_COMMON"] ??
+        process.env["HOME"] ??
         process.env["USERPROFILE"] ??
         "/tmp";
     let envConfig = {

package/dist/server/plugins/index.d.ts

@@ -1,2 +1,2 @@
-export { registerPlugin, getPlugin, getPluginHandler, hasPlugin, getAllPlugins, clearPlugins, unregisterPlugin, } from "./registry";
+export { registerPlugin, registerPlugins, getPlugin, getPluginHandler, hasPlugin, getAllPlugins, clearPlugins, unregisterPlugin, } from "./registry";
 //# sourceMappingURL=index.d.ts.map

package/dist/server/plugins/index.js

@@ -1 +1 @@
-export { registerPlugin, getPlugin, getPluginHandler, hasPlugin, getAllPlugins, clearPlugins, unregisterPlugin, } from "./registry.js";
+export { registerPlugin, registerPlugins, getPlugin, getPluginHandler, hasPlugin, getAllPlugins, clearPlugins, unregisterPlugin, } from "./registry.js";

package/dist/server/plugins/registry.d.ts

@@ -1,5 +1,6 @@
 import { type QvacPlugin, type PluginHandlerDefinition } from "../../schemas/plugin";
 export declare function registerPlugin(plugin: QvacPlugin): void;
+export declare function registerPlugins(pluginList: readonly QvacPlugin[]): void;
 export declare function getPlugin(modelType: string): QvacPlugin | undefined;
 export declare function getPluginHandler(modelType: string, handlerName: string): PluginHandlerDefinition | undefined;
 export declare function hasPlugin(modelType: string): boolean;

package/dist/server/plugins/registry.js

@@ -43,6 +43,11 @@ export function registerPlugin(plugin) {
         loggingModule.setLogger(createAddonLoggerCallback(plugin.logging.namespace));
     }
 }
+export function registerPlugins(pluginList) {
+    for (const plugin of pluginList) {
+        registerPlugin(plugin);
+    }
+}
 export function getPlugin(modelType) {
     return plugins.get(modelType);
 }

package/dist/server/rpc/handler-registry.js

@@ -27,7 +27,9 @@ import { handleFinetune } from "./handlers/finetune.js";
 import { handleHeartbeatDelegated } from "./handlers/heartbeat-delegated.js";
 import { handleCancelDelegated } from "./handlers/cancel-delegated.js";
 import { handleDiffusionStream } from "./handlers/diffusion-stream.js";
+import { handleVideoStream } from "./handlers/video-stream.js";
 import { handleUpscaleStream } from "./handlers/upscale-stream.js";
+import { handleClassify } from "./handlers/classify.js";
 import { handlePluginInvoke, handlePluginInvokeStream, } from "./handlers/plugin-invoke.js";
 import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel, } from "./handlers/registry.js";
 import { handleSuspend } from "./handlers/suspend.js";
@@ -122,7 +124,9 @@ export const registry = {
     textToSpeechStream: { type: "duplex", handler: handleTextToSpeechStream },
     ocrStream: { type: "stream", handler: handleOCRStream },
     diffusionStream: { type: "stream", handler: handleDiffusionStream },
+    videoStream: { type: "stream", handler: handleVideoStream },
     upscaleStream: { type: "stream", handler: handleUpscaleStream },
+    classify: { type: "stream", handler: handleClassify },
     pluginInvokeStream: { type: "stream", handler: handlePluginInvokeStream },
     // Handlers with delegation support
     loadModel: {

package/dist/server/rpc/handler-selection.d.ts

@@ -0,0 +1,9 @@
+import type { Request } from "../../schemas/index";
+import type { HandlerEntry } from "./handler-utils";
+export interface HandlerSelection {
+    handler: HandlerEntry["handler"];
+    isDelegated: boolean;
+}
+export declare function selectHandler(entry: HandlerEntry, request: Request): HandlerSelection;
+export declare function handlerSupportsProgress(entry: HandlerEntry, request: Request): boolean;
+//# sourceMappingURL=handler-selection.d.ts.map

package/dist/server/rpc/handler-selection.js

@@ -0,0 +1,14 @@
+export function selectHandler(entry, request) {
+    const isDelegated = !!(entry.delegatedHandler && entry.isDelegated?.(request));
+    return {
+        handler: isDelegated ? entry.delegatedHandler : entry.handler,
+        isDelegated,
+    };
+}
+export function handlerSupportsProgress(entry, request) {
+    return !!("withProgress" in request &&
+        request.withProgress &&
+        (typeof entry.supportsProgress === "function"
+            ? entry.supportsProgress(request)
+            : entry.supportsProgress));
+}

package/dist/server/rpc/handler-utils.js

@@ -6,6 +6,7 @@ import { setRuntimeContext } from "../bare/registry/runtime-context-registry.js"
 import {} from "./profiling/index.js";
 import { isTerminalChunk } from "./rpc-utils.js";
 import { createProgressThrottle } from "./progress-throttle.js";
+import { handlerSupportsProgress, selectHandler, } from "./handler-selection.js";
 function getProfilingMetaFromRequest(request) {
     if (PROFILING_KEY in request) {
         return request[PROFILING_KEY];
@@ -74,9 +75,7 @@ async function executeProgressHandler(req, request, handler, profiler, isDelegat
     const stream = req.createResponseStream();
     profiler.startHandler();
     const writeBatch = (updates) => {
-        const payload = updates
-            .map((u) => profiler.serialize(u, false))
-            .join("\n");
+        const payload = updates.map((u) => profiler.serialize(u, false)).join("\n");
         stream.write(payload + "\n", "utf-8");
     };
     const throttle = createProgressThrottle(writeBatch);
@@ -105,9 +104,7 @@ async function executeProgressHandler(req, request, handler, profiler, isDelegat
     }
 }
 export async function executeDuplexHandler(_req, request, entry, inputStream, outputStream, profiler) {
-    const handler = entry.delegatedHandler && entry.isDelegated?.(request)
-        ? entry.delegatedHandler
-        : entry.handler;
+    const { handler } = selectHandler(entry, request);
     profiler.startHandler();
     try {
         for await (const response of handler(request, inputStream)) {
@@ -127,13 +124,8 @@ export async function executeDuplexHandler(_req, request, entry, inputStream, ou
 }
 // Unified handler executor with delegation and progress support
 export async function executeHandler(req, request, entry, profiler) {
-    const isDelegated = !!(entry.delegatedHandler && entry.isDelegated?.(request));
-    const handler = isDelegated ? entry.delegatedHandler : entry.handler;
-    const wantsProgress = "withProgress" in request &&
-        request.withProgress &&
-        (typeof entry.supportsProgress === "function"
-            ? entry.supportsProgress(request)
-            : entry.supportsProgress);
+    const { handler, isDelegated } = selectHandler(entry, request);
+    const wantsProgress = handlerSupportsProgress(entry, request);
     if (entry.type === "duplex") {
         throw new PluginHandlerTypeMismatchError(request.type, "reply or stream", "duplex");
     }

package/dist/server/rpc/handlers/classify.d.ts

@@ -0,0 +1,3 @@
+import type { ClassifyRequest, ClassifyResponse } from "../../../schemas/classification";
+export declare function handleClassify(request: ClassifyRequest): AsyncGenerator<ClassifyResponse>;
+//# sourceMappingURL=classify.d.ts.map

package/dist/server/rpc/handlers/classify.js

@@ -0,0 +1,4 @@
+import { dispatchPluginStream } from "./plugin-dispatch.js";
+export async function* handleClassify(request) {
+    yield* dispatchPluginStream(request.modelId, "classify", request);
+}

package/dist/server/rpc/handlers/index.d.ts

@@ -20,6 +20,7 @@ import { handleFinetune } from "./finetune";
 import { handleOCRStream } from "./ocr-stream";
 import { handleHeartbeat } from "./heartbeat";
 import { handleDiffusionStream } from "./diffusion-stream";
+import { handleVideoStream } from "./video-stream";
 import { handleUpscaleStream } from "./upscale-stream";
 import { handlePluginInvoke, handlePluginInvokeStream } from "./plugin-invoke";
 import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel } from "./registry";
@@ -49,6 +50,7 @@ export declare const handlers: {
     finetune: typeof handleFinetune;
     ocrStream: typeof handleOCRStream;
     diffusionStream: typeof handleDiffusionStream;
+    videoStream: typeof handleVideoStream;
     upscaleStream: typeof handleUpscaleStream;
     pluginInvoke: typeof handlePluginInvoke;
     pluginInvokeStream: typeof handlePluginInvokeStream;

package/dist/server/rpc/handlers/index.js

@@ -20,6 +20,7 @@ import { handleFinetune } from "./finetune.js";
 import { handleOCRStream } from "./ocr-stream.js";
 import { handleHeartbeat } from "./heartbeat.js";
 import { handleDiffusionStream } from "./diffusion-stream.js";
+import { handleVideoStream } from "./video-stream.js";
 import { handleUpscaleStream } from "./upscale-stream.js";
 import { handlePluginInvoke, handlePluginInvokeStream } from "./plugin-invoke.js";
 import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel, } from "./registry.js";
@@ -49,6 +50,7 @@ export const handlers = {
     finetune: handleFinetune,
     ocrStream: handleOCRStream,
     diffusionStream: handleDiffusionStream,
+    videoStream: handleVideoStream,
     upscaleStream: handleUpscaleStream,
     pluginInvoke: handlePluginInvoke,
     pluginInvokeStream: handlePluginInvokeStream,

package/dist/server/rpc/handlers/load-model/handler.js

@@ -151,7 +151,10 @@ export async function handleLoadModel(request, progressCallback) {
             if ("modelPath" in pluginArtifacts) {
                 throw new ModelLoadFailedError("Plugin returned reserved key \"modelPath\" in artifacts; primary model resolution is core-owned");
             }
-            if (!resolvedModelPath) {
+            // An empty resolved path is legitimate when the plugin opts out of
+            // primary-model-path validation (bundled weights). For every other
+            // plugin, an empty path means resolution failed and we must abort.
+            if (!resolvedModelPath && !plugin.skipPrimaryModelPathValidation) {
                 throw new ModelLoadFailedError("modelPath resolution failed");
             }
             const loadResult = await loadModel({

package/dist/server/rpc/handlers/load-model/resolve.js

@@ -79,6 +79,15 @@ async function resolveModelPathCore(modelSrc, progressCallback, seed, mode, sign
         throw new InferenceCancelledError(hooks?.requestBinding?.requestId ?? "unknown");
     }
     const srcString = modelInputToSrcSchema.parse(modelSrc);
+    // Empty modelSrc is reserved for plugins that ship bundled weights
+    // (e.g. `@qvac/classification-ggml`). The handler skips this resolver
+    // for them when `skipPrimaryModelPathValidation` is set, but if it
+    // somehow gets called we return an empty path so the plugin's
+    // `params.modelPath` falls through to undefined instead of being set
+    // to the cache directory itself.
+    if (srcString === "") {
+        return { path: "", sourceType: "filesystem" };
+    }
     // Parse hyperdrive URLs if present
     let hyperdriveKey;
     let actualModelSrc = srcString;

package/dist/server/rpc/handlers/video-stream.d.ts

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

package/dist/server/rpc/handlers/video-stream.js

@@ -0,0 +1,4 @@
+import { dispatchPluginStream } from "./plugin-dispatch.js";
+export async function* handleVideoStream(request) {
+    yield* dispatchPluginStream(request.modelId, "videoStream", request);
+}

package/dist/server/rpc/profiling/operation-metrics.js

@@ -242,6 +242,29 @@ registerOperationMetrics({
         return Object.keys(gauges).length > 0 ? gauges : undefined;
     },
 });
+registerOperationMetrics({
+    op: "videoStream",
+    kind: "handler",
+    getTags: (req) => (req.modelId ? { modelId: req.modelId } : {}),
+    fromFinalChunk: (res) => {
+        if (!res.stats)
+            return undefined;
+        const gauges = {};
+        if (res.stats.generationMs !== undefined)
+            gauges["generationMs"] = res.stats.generationMs;
+        if (res.stats.totalSteps !== undefined)
+            gauges["totalSteps"] = res.stats.totalSteps;
+        if (res.stats.totalVideos !== undefined)
+            gauges["totalVideos"] = res.stats.totalVideos;
+        if (res.stats.totalVideoFrames !== undefined)
+            gauges["totalVideoFrames"] = res.stats.totalVideoFrames;
+        if (res.stats.videoFrames !== undefined)
+            gauges["videoFrames"] = res.stats.videoFrames;
+        if (res.stats.fps !== undefined)
+            gauges["fps"] = res.stats.fps;
+        return Object.keys(gauges).length > 0 ? gauges : undefined;
+    },
+});
 registerOperationMetrics({
     op: "pluginInvoke",
     kind: "handler",

package/dist/server/utils/config-transform.js

@@ -14,7 +14,7 @@ export function transformConfigForReload(modelType, config) {
         case ModelType.llamacppCompletion:
         case ModelType.llamacppEmbedding:
         case ModelType.nmtcppTranslation:
-        case ModelType.onnxTts:
+        case ModelType.ttsGgml:
             // Return as-is for now
             return config;
         default: