@qvac/sdk 0.14.1 → 0.15.0

package/dist/server/bare/plugins/llamacpp-embedding/plugin.js

@@ -1,17 +1,17 @@
-import EmbedLlamacpp, {} from "@qvac/embed-llamacpp";
-import embedAddonLogging from "@qvac/embed-llamacpp/addonLogging.js";
-import { definePlugin, defineHandler, embedRequestSchema, embedResponseSchema, ModelType, embedConfigBaseSchema, ADDON_EMBEDDING, } from "../../../../schemas/index.js";
-import { createStreamLogger, registerAddonLogger, getServerLogger } from "../../../../logging/index.js";
-import { expandGGUFIntoShards } from "../../../utils/index.js";
-import { embed } from "../../ops/embed.js";
-import { forwardModelExecution } from "../../../../profiling/model-execution.js";
-import { isMobile } from "../../registry/runtime-context-registry.js";
-import { stripMultiGpuKeys } from "../../../utils/multi-gpu-mobile.js";
+import EmbedLlamacpp, {} from '@qvac/embed-llamacpp';
+import embedAddonLogging from '@qvac/embed-llamacpp/addonLogging.js';
+import { definePlugin, defineHandler, embedRequestSchema, embedResponseSchema, ModelType, embedConfigBaseSchema, ADDON_EMBEDDING } from '../../../../schemas/index.js';
+import { createStreamLogger, registerAddonLogger, getServerLogger } from '../../../../logging/index.js';
+import { expandGGUFIntoShards } from '../../../utils/index.js';
+import { embed } from '../../ops/embed.js';
+import { forwardModelExecution } from '../../../../profiling/model-execution.js';
+import { isMobile } from '../../registry/runtime-context-registry.js';
+import { stripMultiGpuKeys } from '../../../utils/multi-gpu-mobile.js';
 function transformEmbedConfig(embedConfig) {
     const config = {
         device: embedConfig.device,
         gpu_layers: `${embedConfig.gpuLayers}`,
-        batch_size: `${embedConfig.batchSize}`,
+        batch_size: `${embedConfig.batchSize}`
     };
     if (embedConfig.flashAttention) {
         config.flash_attn = embedConfig.flashAttention;
@@ -22,22 +22,20 @@ function transformEmbedConfig(embedConfig) {
     if (embedConfig.attention) {
         config.attention = embedConfig.attention;
     }
-    if (typeof embedConfig.embdNormalize === "number") {
+    if (typeof embedConfig.embdNormalize === 'number') {
         config.embd_normalize = `${embedConfig.embdNormalize}`;
     }
     if (embedConfig.mainGpu !== undefined) {
-        config["main-gpu"] =
-            typeof embedConfig.mainGpu === "number"
-                ? `${embedConfig.mainGpu}`
-                : embedConfig.mainGpu;
+        config['main-gpu'] =
+            typeof embedConfig.mainGpu === 'number' ? `${embedConfig.mainGpu}` : embedConfig.mainGpu;
     }
     if (embedConfig.splitMode) {
-        config["split-mode"] = embedConfig.splitMode;
+        config['split-mode'] = embedConfig.splitMode;
     }
     if (embedConfig.tensorSplit) {
-        config["tensor-split"] = embedConfig.tensorSplit;
+        config['tensor-split'] = embedConfig.tensorSplit;
     }
-    if (typeof embedConfig.verbosity === "number") {
+    if (typeof embedConfig.verbosity === 'number') {
         config.verbosity = `${embedConfig.verbosity}`;
     }
     if (embedConfig.openclCacheDir) {
@@ -52,7 +50,7 @@ function createEmbeddingsModel(modelId, modelPath, embedConfig) {
     if (isMobile()) {
         const stripped = stripMultiGpuKeys(config);
         if (stripped.length > 0) {
-            getServerLogger().warn(`[${ModelType.llamacppEmbedding}:${modelId}] Multi-GPU parameters (${stripped.join(", ")}) are not supported on mobile (single-GPU device) — removing from config; model will load with single-GPU defaults`);
+            getServerLogger().warn(`[${ModelType.llamacppEmbedding}:${modelId}] Multi-GPU parameters (${stripped.join(', ')}) are not supported on mobile (single-GPU device) — removing from config; model will load with single-GPU defaults`);
         }
     }
     const modelFiles = expandGGUFIntoShards(modelPath);
@@ -60,13 +58,13 @@ function createEmbeddingsModel(modelId, modelPath, embedConfig) {
         files: { model: modelFiles },
         config,
         logger,
-        opts: { stats: true },
+        opts: { stats: true }
     });
     return { model };
 }
 export const embeddingsPlugin = definePlugin({
     modelType: ModelType.llamacppEmbedding,
-    displayName: "Embeddings (llama.cpp)",
+    displayName: 'Embeddings (llama.cpp)',
     addonPackage: ADDON_EMBEDDING,
     loadConfigSchema: embedConfigBaseSchema,
     createModel(params) {
@@ -81,23 +79,23 @@ export const embeddingsPlugin = definePlugin({
             streaming: false,
             // Model-wide hard cancel via `addon.cancel()` on the llama.cpp
             // embedding addon. Compute is interrupted when fired.
-            cancel: { scope: "model", hard: true },
+            cancel: { scope: 'model', hard: true },
             handler: async function (request) {
                 const embedResult = await embed({
                     modelId: request.modelId,
-                    text: request.text,
+                    text: request.text
                 }, request.requestId);
                 return forwardModelExecution({
-                    type: "embed",
+                    type: 'embed',
                     success: true,
                     embedding: embedResult.embedding,
-                    ...(embedResult.stats && { stats: embedResult.stats }),
+                    ...(embedResult.stats && { stats: embedResult.stats })
                 }, embedResult);
-            },
-        }),
+            }
+        })
     },
     logging: {
         module: embedAddonLogging,
-        namespace: ModelType.llamacppEmbedding,
-    },
+        namespace: ModelType.llamacppEmbedding
+    }
 });

package/dist/server/bare/plugins/nmtcpp-translation/plugin.d.ts

@@ -1,4 +1,4 @@
-import { type CreateModelParams, type PluginModelResult, type ResolveContext, type ResolveResult } from "../../../../schemas/index";
+import { type CreateModelParams, type PluginModelResult, type ResolveContext, type ResolveResult } from '../../../../schemas/index';
 export declare const nmtPlugin: {
     modelType: "nmtcpp-translation";
     displayName: string;

package/dist/server/bare/plugins/nmtcpp-translation/plugin.js

@@ -1,11 +1,11 @@
-import nmtAddonLogging from "@qvac/translation-nmtcpp/addonLogging.js";
-import TranslationNmtcpp, {} from "@qvac/translation-nmtcpp";
-import { definePlugin, defineHandler, translateRequestSchema, translateResponseSchema, ModelType, nmtConfigBaseSchema, ADDON_NMT, BERGAMOT_CJK_LANG_PAIRS, } from "../../../../schemas/index.js";
-import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
-import path from "bare-path";
-import { translate } from "../../ops/translate.js";
-import { attachModelExecutionMs } from "../../../../profiling/model-execution.js";
-import { resolveBergamotVocab, } from "./resolve-vocab.js";
+import nmtAddonLogging from '@qvac/translation-nmtcpp/addonLogging.js';
+import TranslationNmtcpp, {} from '@qvac/translation-nmtcpp';
+import { definePlugin, defineHandler, translateRequestSchema, translateResponseSchema, ModelType, nmtConfigBaseSchema, ADDON_NMT, BERGAMOT_CJK_LANG_PAIRS } from '../../../../schemas/index.js';
+import { createStreamLogger, registerAddonLogger } from '../../../../logging/index.js';
+import path from 'bare-path';
+import { translate } from '../../ops/translate.js';
+import { attachModelExecutionMs } from '../../../../profiling/model-execution.js';
+import { resolveBergamotVocab } from './resolve-vocab.js';
 /**
  * Derive absolute vocab paths from a resolved Bergamot model path.
  * Works for both companion-set layout (colocated files) and any layout where
@@ -22,7 +22,7 @@ function deriveColocatedBergamotVocabPaths(modelPath) {
     if (BERGAMOT_CJK_LANG_PAIRS.includes(langPair)) {
         return {
             srcVocabPath: path.join(dirPath, `srcvocab.${langPair}.spm`),
-            dstVocabPath: path.join(dirPath, `trgvocab.${langPair}.spm`),
+            dstVocabPath: path.join(dirPath, `trgvocab.${langPair}.spm`)
         };
     }
     const sharedPath = path.join(dirPath, `vocab.${langPair}.spm`);
@@ -31,14 +31,14 @@ function deriveColocatedBergamotVocabPaths(modelPath) {
 function createNmtModel(modelId, modelPath, nmtConfig, srcVocabPath, dstVocabPath, pivotModelPath, pivotSrcVocabPath, pivotDstVocabPath) {
     const logger = createStreamLogger(modelId, ModelType.nmtcppTranslation);
     registerAddonLogger(modelId, ModelType.nmtcppTranslation, logger);
-    const { mode, from, to, engine, beamsize, lengthpenalty, maxlength, repetitionpenalty, norepeatngramsize, temperature, topk, topp, } = nmtConfig;
+    const { mode, from, to, engine, beamsize, lengthpenalty, maxlength, repetitionpenalty, norepeatngramsize, temperature, topk, topp } = nmtConfig;
     const files = {
         model: modelPath,
         ...(srcVocabPath && { srcVocab: srcVocabPath }),
         ...(dstVocabPath && { dstVocab: dstVocabPath }),
         ...(pivotModelPath && { pivotModel: pivotModelPath }),
         ...(pivotSrcVocabPath && { pivotSrcVocab: pivotSrcVocabPath }),
-        ...(pivotDstVocabPath && { pivotDstVocab: pivotDstVocabPath }),
+        ...(pivotDstVocabPath && { pivotDstVocab: pivotDstVocabPath })
     };
     const generationParams = {
         beamsize,
@@ -48,41 +48,42 @@ function createNmtModel(modelId, modelPath, nmtConfig, srcVocabPath, dstVocabPat
         norepeatngramsize,
         temperature,
         topk,
-        topp,
+        topp
     };
     const config = {
         modelType: TranslationNmtcpp.ModelTypes[engine],
         ...generationParams,
-        ...(nmtConfig.engine === "Bergamot" && {
+        ...(nmtConfig.engine === 'Bergamot' && {
             ...(nmtConfig.normalize !== undefined && {
-                normalize: nmtConfig.normalize,
+                normalize: nmtConfig.normalize
             }),
-            ...(nmtConfig.pivotModel && pivotModelPath && {
+            ...(nmtConfig.pivotModel &&
+                pivotModelPath && {
                 pivotConfig: (() => {
                     // eslint-disable-next-line @typescript-eslint/no-unused-vars
                     const { modelSrc, dstVocabSrc, srcVocabSrc, ...pivotGenConfig } = nmtConfig.pivotModel;
                     return pivotGenConfig;
-                })(),
-            }),
-        }),
+                })()
+            })
+        })
     };
     const model = new TranslationNmtcpp({
         files,
         params: { mode, srcLang: from, dstLang: to },
         config,
         logger,
-        opts: { stats: true },
+        opts: { stats: true }
     });
     return { model };
 }
 export const nmtPlugin = definePlugin({
     modelType: ModelType.nmtcppTranslation,
-    displayName: "NMT (nmtcpp)",
+    displayName: 'NMT (nmtcpp)',
     addonPackage: ADDON_NMT,
     loadConfigSchema: nmtConfigBaseSchema,
     async resolveConfig(cfg, ctx) {
         const { srcVocabSrc, dstVocabSrc, pivotModel, ...nmtConfig } = cfg;
-        if (nmtConfig.engine !== "Bergamot") {
+        if (nmtConfig.engine !== 'Bergamot') {
             return { config: nmtConfig };
         }
         const bergamotConfig = { ...nmtConfig, ...(pivotModel && { pivotModel }) };
@@ -92,14 +93,12 @@ export const nmtPlugin = definePlugin({
         const nmtConfig = (params.modelConfig ?? {});
         const artifacts = params.artifacts ?? {};
         const derived = deriveColocatedBergamotVocabPaths(params.modelPath);
-        const srcVocabPath = artifacts["srcVocabPath"] ?? derived?.srcVocabPath;
-        const dstVocabPath = artifacts["dstVocabPath"] ?? derived?.dstVocabPath;
-        const pivotModelPath = artifacts["pivotModelPath"];
-        const pivotDerived = pivotModelPath
-            ? deriveColocatedBergamotVocabPaths(pivotModelPath)
-            : null;
-        const pivotSrcVocabPath = artifacts["pivotSrcVocabPath"] ?? pivotDerived?.srcVocabPath;
-        const pivotDstVocabPath = artifacts["pivotDstVocabPath"] ?? pivotDerived?.dstVocabPath;
+        const srcVocabPath = artifacts['srcVocabPath'] ?? derived?.srcVocabPath;
+        const dstVocabPath = artifacts['dstVocabPath'] ?? derived?.dstVocabPath;
+        const pivotModelPath = artifacts['pivotModelPath'];
+        const pivotDerived = pivotModelPath ? deriveColocatedBergamotVocabPaths(pivotModelPath) : null;
+        const pivotSrcVocabPath = artifacts['pivotSrcVocabPath'] ?? pivotDerived?.srcVocabPath;
+        const pivotDstVocabPath = artifacts['pivotDstVocabPath'] ?? pivotDerived?.dstVocabPath;
         const { model } = createNmtModel(params.modelId, params.modelPath, nmtConfig, srcVocabPath, dstVocabPath, pivotModelPath, pivotSrcVocabPath, pivotDstVocabPath);
         return { model };
     },
@@ -111,34 +110,34 @@ export const nmtPlugin = definePlugin({
             // nmtcpp does not expose a cancel surface today — SDK falls
             // back to soft-cancel (stop yielding, drop result, skip
             // post-processing; the C++ work runs to completion).
-            cancel: { scope: "none" },
+            cancel: { scope: 'none' },
             handler: async function* (request) {
                 const stream = translate(request, request.requestId);
                 try {
                     let result = await stream.next();
                     while (!result.done) {
                         yield {
-                            type: "translate",
-                            token: result.value,
+                            type: 'translate',
+                            token: result.value
                         };
                         result = await stream.next();
                     }
                     const { modelExecutionMs, stats } = result.value;
                     yield attachModelExecutionMs({
-                        type: "translate",
-                        token: "",
+                        type: 'translate',
+                        token: '',
                         done: true,
-                        ...(stats && { stats }),
+                        ...(stats && { stats })
                     }, modelExecutionMs);
                 }
                 finally {
                     await stream.return?.(undefined);
                 }
-            },
-        }),
+            }
+        })
     },
     logging: {
         module: nmtAddonLogging,
-        namespace: ModelType.nmtcppTranslation,
-    },
+        namespace: ModelType.nmtcppTranslation
+    }
 });

package/dist/server/bare/plugins/nmtcpp-translation/resolve-vocab.d.ts

@@ -1,4 +1,4 @@
-import { type ModelSrcInput, type NmtConfig, type ResolveContext, type ResolveResult } from "../../../../schemas/index";
+import { type ModelSrcInput, type NmtConfig, type ResolveContext, type ResolveResult } from '../../../../schemas/index';
 export interface PivotModelConfig {
     modelSrc: string;
     srcVocabSrc?: ModelSrcInput;

package/dist/server/bare/plugins/nmtcpp-translation/resolve-vocab.js

@@ -1,10 +1,10 @@
-import { BERGAMOT_CJK_LANG_PAIRS, } from "../../../../schemas/index.js";
-import { ModelLoadFailedError } from "../../../../utils/errors-server.js";
+import { BERGAMOT_CJK_LANG_PAIRS } from '../../../../schemas/index.js';
+import { ModelLoadFailedError } from '../../../../utils/errors-server.js';
 export function buildBergamotVocabSources(basePath, langPair) {
     if (BERGAMOT_CJK_LANG_PAIRS.includes(langPair)) {
         return {
             srcVocabSrc: `${basePath}srcvocab.${langPair}.spm`,
-            dstVocabSrc: `${basePath}trgvocab.${langPair}.spm`,
+            dstVocabSrc: `${basePath}trgvocab.${langPair}.spm`
         };
     }
     const sharedVocab = `${basePath}vocab.${langPair}.spm`;
@@ -42,9 +42,9 @@ export async function resolveBergamotVocab(nmtConfig, ctx, srcVocabSrc, dstVocab
     let srcSrc = srcVocabSrc;
     let dstSrc = dstVocabSrc;
     if (!srcSrc || !dstSrc) {
-        const derived = ctx.modelSrc.startsWith("pear://")
+        const derived = ctx.modelSrc.startsWith('pear://')
             ? deriveBergamotVocabSources(ctx.modelSrc)
-            : ctx.modelSrc.startsWith("registry://")
+            : ctx.modelSrc.startsWith('registry://')
                 ? deriveBergamotRegistryVocabSources(ctx.modelSrc)
                 : null;
         if (derived) {
@@ -53,29 +53,29 @@ export async function resolveBergamotVocab(nmtConfig, ctx, srcVocabSrc, dstVocab
         }
     }
     if (!srcSrc || !dstSrc) {
-        throw new ModelLoadFailedError("Bergamot requires srcVocabSrc and dstVocabSrc. Provide them in modelConfig or use a pear:// or registry:// model source for auto-derivation.");
+        throw new ModelLoadFailedError('Bergamot requires srcVocabSrc and dstVocabSrc. Provide them in modelConfig or use a pear:// or registry:// model source for auto-derivation.');
     }
     if (!pivotModel) {
-        const modelIsRegistry = ctx.modelSrc.startsWith("registry://");
+        const modelIsRegistry = ctx.modelSrc.startsWith('registry://');
         const vocabsAreDerived = !srcVocabSrc && !dstVocabSrc;
         if (modelIsRegistry && vocabsAreDerived) {
             return { config: nmtConfig };
         }
         const [srcVocabPath, dstVocabPath] = await Promise.all([
             ctx.resolveModelPath(srcSrc),
-            ctx.resolveModelPath(dstSrc),
+            ctx.resolveModelPath(dstSrc)
         ]);
         return {
             config: nmtConfig,
-            artifacts: { srcVocabPath, dstVocabPath },
+            artifacts: { srcVocabPath, dstVocabPath }
         };
     }
     let pivotSrcSrc = pivotModel.srcVocabSrc;
     let pivotDstSrc = pivotModel.dstVocabSrc;
     if (!pivotSrcSrc || !pivotDstSrc) {
-        const pivotDerived = pivotModel.modelSrc.startsWith("pear://")
+        const pivotDerived = pivotModel.modelSrc.startsWith('pear://')
             ? deriveBergamotVocabSources(pivotModel.modelSrc)
-            : pivotModel.modelSrc.startsWith("registry://")
+            : pivotModel.modelSrc.startsWith('registry://')
                 ? deriveBergamotRegistryVocabSources(pivotModel.modelSrc)
                 : null;
         if (pivotDerived) {
@@ -84,25 +84,22 @@ export async function resolveBergamotVocab(nmtConfig, ctx, srcVocabSrc, dstVocab
         }
     }
     if (!pivotSrcSrc || !pivotDstSrc) {
-        throw new ModelLoadFailedError("Bergamot pivot model requires srcVocabSrc and dstVocabSrc. Provide them in modelConfig or use a pear:// or registry:// model source for auto-derivation.");
+        throw new ModelLoadFailedError('Bergamot pivot model requires srcVocabSrc and dstVocabSrc. Provide them in modelConfig or use a pear:// or registry:// model source for auto-derivation.');
     }
-    const modelIsRegistry = ctx.modelSrc.startsWith("registry://");
-    const pivotIsRegistry = pivotModel.modelSrc.startsWith("registry://");
+    const modelIsRegistry = ctx.modelSrc.startsWith('registry://');
+    const pivotIsRegistry = pivotModel.modelSrc.startsWith('registry://');
     const primaryVocabsAreDerived = !srcVocabSrc && !dstVocabSrc;
     const pivotVocabsAreDerived = !pivotModel.srcVocabSrc && !pivotModel.dstVocabSrc;
-    if (modelIsRegistry &&
-        pivotIsRegistry &&
-        primaryVocabsAreDerived &&
-        pivotVocabsAreDerived) {
+    if (modelIsRegistry && pivotIsRegistry && primaryVocabsAreDerived && pivotVocabsAreDerived) {
         const pivotModelPath = await ctx.resolveModelPath(pivotModel.modelSrc);
         return { config: nmtConfig, artifacts: { pivotModelPath } };
     }
-    const [srcVocabPath, dstVocabPath, pivotSrcVocabPath, pivotDstVocabPath, pivotModelPath,] = await Promise.all([
+    const [srcVocabPath, dstVocabPath, pivotSrcVocabPath, pivotDstVocabPath, pivotModelPath] = await Promise.all([
         ctx.resolveModelPath(srcSrc),
         ctx.resolveModelPath(dstSrc),
         ctx.resolveModelPath(pivotSrcSrc),
         ctx.resolveModelPath(pivotDstSrc),
-        ctx.resolveModelPath(pivotModel.modelSrc),
+        ctx.resolveModelPath(pivotModel.modelSrc)
     ]);
     return {
         config: nmtConfig,
@@ -111,7 +108,7 @@ export async function resolveBergamotVocab(nmtConfig, ctx, srcVocabSrc, dstVocab
             dstVocabPath,
             pivotSrcVocabPath,
             pivotDstVocabPath,
-            pivotModelPath,
-        },
+            pivotModelPath
+        }
     };
 }

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

@@ -1,4 +1,4 @@
-import { type ParakeetConfig, type CreateModelParams, type PluginModelResult, type ResolveResult } from "../../../../schemas/index";
+import { type ParakeetConfig, type CreateModelParams, type PluginModelResult, type ResolveResult } from '../../../../schemas/index';
 export declare const parakeetPlugin: {
     modelType: "parakeet-transcription";
     displayName: string;

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

@@ -1,10 +1,10 @@
-import parakeetAddonLogging from "@qvac/transcription-parakeet/addonLogging.js";
-import TranscriptionParakeet, {} from "@qvac/transcription-parakeet";
-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, TranscriptionFailedError, LegacyParakeetModelDeprecatedError, } from "../../../../utils/errors-server.js";
-import { transcribe, transcribeStream } from "../../ops/transcribe.js";
-import { attachModelExecutionMs } from "../../../../profiling/model-execution.js";
+import parakeetAddonLogging from '@qvac/transcription-parakeet/addonLogging.js';
+import TranscriptionParakeet, {} from '@qvac/transcription-parakeet';
+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, TranscriptionFailedError, LegacyParakeetModelDeprecatedError } from '../../../../utils/errors-server.js';
+import { transcribe, transcribeStream } from '../../ops/transcribe.js';
+import { attachModelExecutionMs } from '../../../../profiling/model-execution.js';
 function resolveParakeetConfig(cfg) {
     const cfgRecord = cfg;
     const legacyFields = LEGACY_PARAKEET_ONNX_MODEL_CONFIG_FIELDS.filter((name) => cfgRecord[name] !== undefined);
@@ -17,28 +17,28 @@ function createParakeetModel(params) {
     const config = (params.modelConfig ?? {});
     const modelPath = params.modelPath;
     if (!modelPath) {
-        throw new ModelLoadFailedError("Parakeet requires a GGUF model source");
+        throw new ModelLoadFailedError('Parakeet requires a GGUF model source');
     }
     const logger = createStreamLogger(params.modelId, ModelType.parakeetTranscription);
     registerAddonLogger(params.modelId, ModelType.parakeetTranscription, logger);
     const files = {
-        model: modelPath,
+        model: modelPath
     };
     const parakeetConfig = Object.fromEntries(Object.entries(config).filter(([, value]) => value !== undefined));
     const addonConfig = {
         enableStats: true,
-        parakeetConfig,
+        parakeetConfig
     };
     const model = new TranscriptionParakeet({
         files,
         config: addonConfig,
-        logger,
+        logger
     });
     return { model };
 }
 export const parakeetPlugin = definePlugin({
     modelType: ModelType.parakeetTranscription,
-    displayName: "Parakeet (NVIDIA NeMo GGML)",
+    displayName: 'Parakeet (NVIDIA NeMo GGML)',
     addonPackage: ADDON_PARAKEET,
     loadConfigSchema: parakeetLoadConfigSchema,
     resolveConfig(cfg) {
@@ -52,7 +52,7 @@ export const parakeetPlugin = definePlugin({
             requestSchema: transcribeRequestSchema,
             responseSchema: transcribeResponseSchema,
             streaming: true,
-            cancel: { scope: "model", hard: true },
+            cancel: { scope: 'model', hard: 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.`);
@@ -60,36 +60,36 @@ export const parakeetPlugin = definePlugin({
                 const stream = transcribe({
                     modelId: request.modelId,
                     audioChunk: request.audioChunk,
-                    prompt: request.prompt,
+                    prompt: request.prompt
                 }, request.requestId);
                 try {
                     let result = await stream.next();
                     while (!result.done) {
                         yield {
-                            type: "transcribe",
-                            text: result.value,
+                            type: 'transcribe',
+                            text: result.value
                         };
                         result = await stream.next();
                     }
                     const { modelExecutionMs, stats } = result.value;
                     yield attachModelExecutionMs({
-                        type: "transcribe",
-                        text: "",
+                        type: 'transcribe',
+                        text: '',
                         done: true,
-                        ...(stats && { stats }),
+                        ...(stats && { stats })
                     }, modelExecutionMs);
                 }
                 finally {
                     await stream.return?.(undefined);
                 }
-            },
+            }
         }),
         transcribeStream: defineDuplexHandler({
             requestSchema: transcribeStreamRequestSchema,
             responseSchema: transcribeStreamResponseSchema,
             streaming: true,
             duplex: true,
-            cancel: { scope: "model", hard: 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
@@ -103,35 +103,35 @@ export const parakeetPlugin = definePlugin({
                 }
                 const streamOpts = {
                     ...(request.parakeetStreamingConfig && {
-                        parakeetStreamingConfig: 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") {
+                    if (typeof value === 'object' && value !== null && 'type' in value) {
+                        if (value.type === 'endOfTurn') {
                             yield {
-                                type: "transcribeStream",
-                                endOfTurn: { source: "parakeet" },
+                                type: 'transcribeStream',
+                                endOfTurn: { source: 'parakeet' }
                             };
                         }
                         continue;
                     }
                     yield {
-                        type: "transcribeStream",
-                        text: value,
+                        type: 'transcribeStream',
+                        text: value
                     };
                 }
                 yield {
-                    type: "transcribeStream",
-                    text: "",
-                    done: true,
+                    type: 'transcribeStream',
+                    text: '',
+                    done: true
                 };
-            },
-        }),
+            }
+        })
     },
     logging: {
         module: parakeetAddonLogging,
-        namespace: ModelType.parakeetTranscription,
-    },
+        namespace: ModelType.parakeetTranscription
+    }
 });

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

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

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

@@ -1,11 +1,9 @@
-import { getModel } from "../../../registry/model-registry.js";
+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 init_image = request.init_image ? Buffer.from(request.init_image, 'base64') : undefined;
     const init_images = request.init_images
-        ? request.init_images.map((b64) => Buffer.from(b64, "base64"))
+        ? request.init_images.map((b64) => Buffer.from(b64, 'base64'))
         : undefined;
     const response = await model.run({
         prompt: request.prompt,
@@ -28,26 +26,26 @@ export async function* diffusion(request) {
         auto_resize_ref_image: request.auto_resize_ref_image,
         strength: request.strength,
         lora: request.lora,
-        upscale: request.upscale === false ? undefined : request.upscale,
+        upscale: request.upscale === false ? undefined : request.upscale
     });
     let outputIndex = 0;
     for await (const chunk of response.iterate()) {
         if (chunk instanceof Uint8Array) {
             yield {
-                type: "diffusionStream",
-                data: Buffer.from(chunk).toString("base64"),
-                outputIndex: outputIndex++,
+                type: 'diffusionStream',
+                data: Buffer.from(chunk).toString('base64'),
+                outputIndex: outputIndex++
             };
         }
-        else if (typeof chunk === "string") {
+        else if (typeof chunk === 'string') {
             try {
                 const tick = JSON.parse(chunk);
-                if ("step" in tick) {
+                if ('step' in tick) {
                     yield {
-                        type: "diffusionStream",
-                        step: tick["step"],
-                        totalSteps: tick["total"],
-                        elapsedMs: tick["elapsed_ms"],
+                        type: 'diffusionStream',
+                        step: tick['step'],
+                        totalSteps: tick['total'],
+                        elapsedMs: tick['elapsed_ms']
                     };
                 }
             }
@@ -58,8 +56,8 @@ export async function* diffusion(request) {
     }
     const responseWithStats = response;
     yield {
-        type: "diffusionStream",
+        type: 'diffusionStream',
         done: true,
-        stats: responseWithStats.stats ?? undefined,
+        stats: responseWithStats.stats ?? undefined
     };
 }

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

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