@qvac/sdk 0.11.0 → 0.12.1

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

@@ -1,96 +1,33 @@
 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 { definePlugin, defineHandler, defineDuplexHandler, transcribeRequestSchema, transcribeResponseSchema, transcribeStreamRequestSchema, transcribeStreamResponseSchema, ModelType, parakeetLoadConfigSchema, LEGACY_PARAKEET_ONNX_MODEL_CONFIG_FIELDS, ADDON_PARAKEET, } from "../../../../schemas/index.js";
 import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
-import { ModelLoadFailedError, ParakeetArtifactsRequiredError, TranscriptionFailedError, } from "../../../../utils/errors-server.js";
-import { transcribe } from "../../ops/transcribe.js";
+import { ModelLoadFailedError, TranscriptionFailedError, LegacyParakeetModelDeprecatedError, } from "../../../../utils/errors-server.js";
+import { transcribe, transcribeStream } from "../../ops/transcribe.js";
 import { attachModelExecutionMs } from "../../../../profiling/model-execution.js";
-async function resolveTdtConfig(cfg, ctx) {
-    const { parakeetEncoderSrc, parakeetEncoderDataSrc, parakeetDecoderSrc, parakeetVocabSrc, parakeetPreprocessorSrc, } = cfg;
-    if (!parakeetEncoderSrc ||
-        !parakeetDecoderSrc ||
-        !parakeetVocabSrc ||
-        !parakeetPreprocessorSrc) {
-        throw new ParakeetArtifactsRequiredError("TDT requires: parakeetEncoderSrc, parakeetDecoderSrc, parakeetVocabSrc, parakeetPreprocessorSrc");
+function resolveParakeetConfig(cfg) {
+    const cfgRecord = cfg;
+    const legacyFields = LEGACY_PARAKEET_ONNX_MODEL_CONFIG_FIELDS.filter((name) => cfgRecord[name] !== undefined);
+    if (legacyFields.length > 0) {
+        throw new LegacyParakeetModelDeprecatedError(legacyFields);
     }
-    const resolve = ctx.resolveModelPath;
-    const [encoderPath, encoderDataPath, decoderPath, vocabPath, preprocessorPath,] = await Promise.all([
-        resolve(parakeetEncoderSrc),
-        parakeetEncoderDataSrc ? resolve(parakeetEncoderDataSrc) : undefined,
-        resolve(parakeetDecoderSrc),
-        resolve(parakeetVocabSrc),
-        resolve(parakeetPreprocessorSrc),
-    ]);
-    return {
-        config: cfg,
-        artifacts: {
-            encoder: encoderPath,
-            ...(encoderDataPath !== undefined && { encoderData: encoderDataPath }),
-            ...(decoderPath !== undefined && { decoder: decoderPath }),
-            ...(vocabPath !== undefined && { vocab: vocabPath }),
-            ...(preprocessorPath !== undefined && { preprocessor: preprocessorPath }),
-        },
-    };
-}
-async function resolveCtcConfig(cfg, ctx) {
-    const { parakeetCtcModelSrc, parakeetCtcModelDataSrc, parakeetTokenizerSrc } = cfg;
-    if (!parakeetCtcModelSrc || !parakeetTokenizerSrc) {
-        throw new ParakeetArtifactsRequiredError("CTC requires: parakeetCtcModelSrc, parakeetTokenizerSrc");
-    }
-    const resolve = ctx.resolveModelPath;
-    const [ctcModelPath, ctcModelDataPath, tokenizerPath] = await Promise.all([
-        resolve(parakeetCtcModelSrc),
-        parakeetCtcModelDataSrc ? resolve(parakeetCtcModelDataSrc) : undefined,
-        resolve(parakeetTokenizerSrc),
-    ]);
-    return {
-        config: cfg,
-        artifacts: {
-            model: ctcModelPath,
-            ...(ctcModelDataPath !== undefined && { modelData: ctcModelDataPath }),
-            ...(tokenizerPath !== undefined && { tokenizer: tokenizerPath }),
-        },
-    };
+    return Promise.resolve({ config: cfg });
 }
-async function resolveSortformerConfig(cfg, ctx) {
-    const { parakeetSortformerSrc } = cfg;
-    if (!parakeetSortformerSrc) {
-        throw new ParakeetArtifactsRequiredError("Sortformer requires: parakeetSortformerSrc");
-    }
-    const resolve = ctx.resolveModelPath;
-    const sortformerPath = await resolve(parakeetSortformerSrc);
-    return {
-        config: cfg,
-        artifacts: {
-            ...(sortformerPath !== undefined && { sortformer: sortformerPath }),
-        },
-    };
-}
-function createParakeetModel(params, primaryFileKey) {
+function createParakeetModel(params) {
     const config = (params.modelConfig ?? {});
-    const artifacts = { ...(params.artifacts ?? {}) };
-    const modelType = config.modelType ?? "tdt";
-    const primaryPath = artifacts[primaryFileKey] ?? params.modelPath;
-    if (!primaryPath) {
-        throw new ModelLoadFailedError(`Parakeet ${modelType} requires a model source`);
+    const modelPath = params.modelPath;
+    if (!modelPath) {
+        throw new ModelLoadFailedError("Parakeet requires a GGUF model source");
     }
     const logger = createStreamLogger(params.modelId, ModelType.parakeetTranscription);
     registerAddonLogger(params.modelId, ModelType.parakeetTranscription, logger);
     const files = {
-        [primaryFileKey]: primaryPath,
-        ...artifacts,
+        model: modelPath,
     };
+    const parakeetConfig = Object.fromEntries(Object.entries(config).filter(([, value]) => value !== undefined));
     const addonConfig = {
         enableStats: true,
-        parakeetConfig: {
-            modelType,
-            maxThreads: config.maxThreads,
-            useGPU: config.useGPU,
-            sampleRate: config.sampleRate,
-            channels: config.channels,
-            captionEnabled: config.captionEnabled,
-            timestampsEnabled: config.timestampsEnabled,
-        },
+        parakeetConfig,
     };
     const model = new TranscriptionParakeet({
         files,
@@ -101,33 +38,20 @@ function createParakeetModel(params, primaryFileKey) {
 }
 export const parakeetPlugin = definePlugin({
     modelType: ModelType.parakeetTranscription,
-    displayName: "Parakeet (NVIDIA NeMo ONNX)",
+    displayName: "Parakeet (NVIDIA NeMo GGML)",
     addonPackage: ADDON_PARAKEET,
-    loadConfigSchema: parakeetConfigSchema,
-    skipPrimaryModelPathValidation: true,
-    async resolveConfig(cfg, ctx) {
-        const modelType = cfg.modelType ?? "tdt";
-        if (modelType === "ctc")
-            return resolveCtcConfig(cfg, ctx);
-        if (modelType === "sortformer")
-            return resolveSortformerConfig(cfg, ctx);
-        return resolveTdtConfig(cfg, ctx);
+    loadConfigSchema: parakeetLoadConfigSchema,
+    resolveConfig(cfg) {
+        return resolveParakeetConfig(cfg);
     },
     createModel(params) {
-        const modelType = (params.modelConfig ?? {}).modelType ?? "tdt";
-        if (modelType === "ctc")
-            return createParakeetModel(params, "model");
-        if (modelType === "sortformer")
-            return createParakeetModel(params, "sortformer");
-        return createParakeetModel(params, "encoder");
+        return createParakeetModel(params);
     },
     handlers: {
         transcribe: defineHandler({
             requestSchema: transcribeRequestSchema,
             responseSchema: transcribeResponseSchema,
             streaming: true,
-            // Parakeet addon exposes a model-wide hard cancel — compute is
-            // interrupted on the currently-running transcription.
             cancel: { scope: "model", hard: true },
             handler: async function* (request) {
                 if (request.metadata === true) {
@@ -160,6 +84,51 @@ export const parakeetPlugin = definePlugin({
                 }
             },
         }),
+        transcribeStream: defineDuplexHandler({
+            requestSchema: transcribeStreamRequestSchema,
+            responseSchema: transcribeStreamResponseSchema,
+            streaming: true,
+            duplex: true,
+            cancel: { scope: "model", hard: true },
+            // TODO(QVAC-17869-followup): wire `AbortSignal` through the duplex
+            // handler signature so the worker learns about consumer disconnects
+            // without depending on `inputStream.end()` (which does not fire if the
+            // client drops packets while TCP stays alive). Under sustained slow
+            // consumers, `runStreaming` may buffer between the server generator and
+            // the duplex RPC writer — backpressure is not yet characterised. Pair
+            // the fix with request-lifecycle `cancel({ requestId })` routing.
+            handler: async function* (request, inputStream) {
+                if (request.metadata === true) {
+                    throw new TranscriptionFailedError(`Parakeet transcribeStream does not support metadata: true; only the whisper engine emits per-segment metadata.`);
+                }
+                const streamOpts = {
+                    ...(request.parakeetStreamingConfig && {
+                        parakeetStreamingConfig: request.parakeetStreamingConfig,
+                    }),
+                };
+                const iterator = transcribeStream(request.modelId, inputStream, undefined, false, streamOpts, request.requestId);
+                for await (const value of iterator) {
+                    if (typeof value === "object" && value !== null && "type" in value) {
+                        if (value.type === "endOfTurn") {
+                            yield {
+                                type: "transcribeStream",
+                                endOfTurn: { source: "parakeet" },
+                            };
+                        }
+                        continue;
+                    }
+                    yield {
+                        type: "transcribeStream",
+                        text: value,
+                    };
+                }
+                yield {
+                    type: "transcribeStream",
+                    text: "",
+                    done: true,
+                };
+            },
+        }),
     },
     logging: {
         module: parakeetAddonLogging,

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

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

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

@@ -0,0 +1,199 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { VideoStableDiffusion } from "@qvac/diffusion-cpp";
+import { getServerLogger } from "../../../../../logging/index.js";
+import { getModel, getModelEntry, } from "../../../registry/model-registry.js";
+import { getRequestRegistry, withRequestContext } from "../../../runtime/index.js";
+import { generateServerRequestId } from "../../../runtime/request-id.js";
+import { ModelOperationNotSupportedError } from "../../../../../utils/errors-server.js";
+import { ModelType } from "../../../../../schemas/index.js";
+// The diffusion plugin instantiates `VideoStableDiffusion` when the model is
+// loaded with `modelConfig.mode === "video"` and `ImgStableDiffusion` (or
+// `EsrganUpscaler`) otherwise. Those have no video `run()` shape, so we refuse
+// the call upfront with a structured error rather than letting a native-addon
+// error propagate.
+function asVideoModel(model, modelId) {
+    if (model instanceof VideoStableDiffusion) {
+        return model;
+    }
+    const entry = getModelEntry(modelId);
+    const modelType = entry && !entry.isDelegated
+        ? entry.local.modelType
+        : ModelType.sdcppGeneration;
+    throw new ModelOperationNotSupportedError(modelId, modelType, "video", ["diffusion"], []);
+}
+export async function* video(request) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const ctx = __addDisposableResource(env_1, getRequestRegistry().begin({
+            requestId: request.requestId ?? generateServerRequestId(),
+            kind: "diffusion",
+            modelId: request.modelId,
+        }), true);
+        const requestLogger = withRequestContext(getServerLogger(), ctx);
+        const model = asVideoModel(getModel(request.modelId), request.modelId);
+        const onAbort = () => {
+            model.cancel().catch((err) => {
+                requestLogger.warn(`[cancel] model.cancel() rejected during abort for modelId=${request.modelId}: ${err instanceof Error ? err.message : String(err)}`);
+            });
+        };
+        ctx.signal.addEventListener("abort", onAbort, { once: true });
+        if (ctx.signal.aborted)
+            onAbort();
+        ctx.scope.defer(() => {
+            ctx.signal.removeEventListener("abort", onAbort);
+        });
+        const response = await model.run({
+            mode: request.mode,
+            prompt: request.prompt,
+            ...(request.negative_prompt !== undefined && {
+                negative_prompt: request.negative_prompt,
+            }),
+            ...(request.width !== undefined && { width: request.width }),
+            ...(request.height !== undefined && { height: request.height }),
+            ...(request.video_frames !== undefined && {
+                video_frames: request.video_frames,
+            }),
+            ...(request.fps !== undefined && { fps: request.fps }),
+            ...(request.seed !== undefined && { seed: request.seed }),
+            ...(request.steps !== undefined && { steps: request.steps }),
+            ...(request.sampling_method !== undefined && {
+                sampling_method: request.sampling_method,
+            }),
+            ...(request.scheduler !== undefined && { scheduler: request.scheduler }),
+            ...(request.cfg_scale !== undefined && { cfg_scale: request.cfg_scale }),
+            ...(request.flow_shift !== undefined && { flow_shift: request.flow_shift }),
+            ...(request.high_noise_steps !== undefined && {
+                high_noise_steps: request.high_noise_steps,
+            }),
+            ...(request.high_noise_sampler !== undefined && {
+                high_noise_sampler: request.high_noise_sampler,
+            }),
+            ...(request.high_noise_scheduler !== undefined && {
+                high_noise_scheduler: request.high_noise_scheduler,
+            }),
+            ...(request.high_noise_cfg_scale !== undefined && {
+                high_noise_cfg_scale: request.high_noise_cfg_scale,
+            }),
+            ...(request.high_noise_flow_shift !== undefined && {
+                high_noise_flow_shift: request.high_noise_flow_shift,
+            }),
+            ...(request.moe_boundary !== undefined && {
+                moe_boundary: request.moe_boundary,
+            }),
+            ...(request.vace_strength !== undefined && {
+                vace_strength: request.vace_strength,
+            }),
+            ...(request.control_frames !== undefined && {
+                control_frames: request.control_frames.map((b64) => Buffer.from(b64, "base64")),
+            }),
+            ...(request.vae_tiling !== undefined && { vae_tiling: request.vae_tiling }),
+            ...(request.vae_tile_size !== undefined && {
+                vae_tile_size: request.vae_tile_size,
+            }),
+            ...(request.vae_tile_overlap !== undefined && {
+                vae_tile_overlap: request.vae_tile_overlap,
+            }),
+            ...(request.cache_mode !== undefined && { cache_mode: request.cache_mode }),
+            ...(request.cache_preset !== undefined && {
+                cache_preset: request.cache_preset,
+            }),
+            ...(request.cache_threshold !== undefined && {
+                cache_threshold: request.cache_threshold,
+            }),
+        });
+        let outputIndex = 0;
+        for await (const chunk of response.iterate()) {
+            if (ctx.signal.aborted)
+                break;
+            if (chunk instanceof Uint8Array) {
+                yield {
+                    type: "videoStream",
+                    data: Buffer.from(chunk).toString("base64"),
+                    outputIndex: outputIndex++,
+                };
+            }
+            else if (typeof chunk === "string") {
+                try {
+                    const tick = JSON.parse(chunk);
+                    if ("step" in tick) {
+                        yield {
+                            type: "videoStream",
+                            step: tick["step"],
+                            totalSteps: tick["total"],
+                            elapsedMs: tick["elapsed_ms"],
+                        };
+                    }
+                }
+                catch {
+                    // Non-JSON string output — skip
+                }
+            }
+        }
+        const responseWithStats = response;
+        yield {
+            type: "videoStream",
+            done: true,
+            stats: responseWithStats.stats ?? undefined,
+        };
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            await result_1;
+    }
+}