@qvac/sdk 0.18.2 → 0.19.0

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

@@ -1,144 +0,0 @@
-import nmtAddonLogging from '@qvac/translation-nmtcpp/addonLogging';
-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 '../../../../server/bare/ops/translate.js';
-import { attachModelExecutionMs } from '../../../../profiling/model-execution.js';
-import { resolveBergamotVocab } from '../../../../server/bare/plugins/nmtcpp-translation/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
- * vocab follows the standard naming convention beside the model binary.
- * Returns null if modelPath is not a recognisable Bergamot model.
- */
-function deriveColocatedBergamotVocabPaths(modelPath) {
-    const dirPath = path.dirname(modelPath);
-    const basePath = path.basename(modelPath);
-    const match = basePath.match(/^model\.([a-z]+)\.intgemm\.alphas\.bin$/);
-    if (!match?.[1])
-        return null;
-    const langPair = match[1];
-    if (BERGAMOT_CJK_LANG_PAIRS.includes(langPair)) {
-        return {
-            srcVocabPath: path.join(dirPath, `srcvocab.${langPair}.spm`),
-            dstVocabPath: path.join(dirPath, `trgvocab.${langPair}.spm`)
-        };
-    }
-    const sharedPath = path.join(dirPath, `vocab.${langPair}.spm`);
-    return { srcVocabPath: sharedPath, dstVocabPath: sharedPath };
-}
-function createNmtModel(modelId, modelPath, nmtConfig, srcVocabPath, dstVocabPath, pivotModelPath, pivotSrcVocabPath, pivotDstVocabPath) {
-    const logger = createStreamLogger(modelId, ModelType.nmtcppTranslation);
-    registerAddonLogger(modelId, ModelType.nmtcppTranslation, logger);
-    const { 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 })
-    };
-    const generationParams = {
-        beamsize,
-        lengthpenalty,
-        maxlength,
-        repetitionpenalty,
-        norepeatngramsize,
-        temperature,
-        topk,
-        topp
-    };
-    const config = {
-        modelType: TranslationNmtcpp.ModelTypes[engine],
-        ...generationParams,
-        ...(nmtConfig.engine === 'Bergamot' && {
-            ...(nmtConfig.normalize !== undefined && {
-                normalize: nmtConfig.normalize
-            }),
-            ...(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: { srcLang: from, dstLang: to },
-        config,
-        logger,
-        opts: { stats: true }
-    });
-    return { model };
-}
-export const nmtPlugin = definePlugin({
-    modelType: ModelType.nmtcppTranslation,
-    displayName: 'NMT (nmtcpp)',
-    addonPackage: ADDON_NMT,
-    loadConfigSchema: nmtConfigBaseSchema,
-    async resolveConfig(cfg, ctx) {
-        const { srcVocabSrc, dstVocabSrc, pivotModel, ...nmtConfig } = cfg;
-        if (nmtConfig.engine !== 'Bergamot') {
-            return { config: nmtConfig };
-        }
-        const bergamotConfig = { ...nmtConfig, ...(pivotModel && { pivotModel }) };
-        return resolveBergamotVocab(bergamotConfig, ctx, srcVocabSrc, dstVocabSrc, pivotModel);
-    },
-    createModel(params) {
-        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 { model } = createNmtModel(params.modelId, params.modelPath, nmtConfig, srcVocabPath, dstVocabPath, pivotModelPath, pivotSrcVocabPath, pivotDstVocabPath);
-        return { model };
-    },
-    handlers: {
-        translate: defineHandler({
-            requestSchema: translateRequestSchema,
-            responseSchema: translateResponseSchema,
-            streaming: true,
-            // nmtcpp 0.7.0 exposes response.cancel(), but the translate op is not
-            // wired for addon-level cancellation yet — SDK keeps soft-cancel (stop
-            // yielding, drop result, skip post-processing; the C++ work may run to
-            // completion).
-            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
-                        };
-                        result = await stream.next();
-                    }
-                    const { modelExecutionMs, stats } = result.value;
-                    yield attachModelExecutionMs({
-                        type: 'translate',
-                        token: '',
-                        done: true,
-                        ...(stats && { stats })
-                    }, modelExecutionMs);
-                }
-                finally {
-                    await stream.return?.(undefined);
-                }
-            }
-        })
-    },
-    logging: {
-        module: nmtAddonLogging,
-        namespace: ModelType.nmtcppTranslation
-    }
-});

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

@@ -1,32 +0,0 @@
-import { type ModelSrcInput, type NmtConfig, type ResolveContext, type ResolveResult } from '../../../../schemas/index.js';
-export interface PivotModelConfig {
-    modelSrc: string;
-    srcVocabSrc?: ModelSrcInput;
-    dstVocabSrc?: ModelSrcInput;
-}
-export declare function buildBergamotVocabSources(basePath: string, langPair: string): {
-    srcVocabSrc: string;
-    dstVocabSrc: string;
-};
-export declare function deriveBergamotVocabSources(modelSrc: string): {
-    srcVocabSrc: string;
-    dstVocabSrc: string;
-} | null;
-export declare function deriveBergamotRegistryVocabSources(modelSrc: string): {
-    srcVocabSrc: string;
-    dstVocabSrc: string;
-} | null;
-/**
- * Resolves Bergamot vocab sources to absolute filesystem paths via the SDK
- * resolver context, optionally including a pivot model.
- *
- * For `registry://` sources with auto-derived vocabs, this skips per-vocab
- * resolution because the companion-set download already colocates the vocabs
- * next to the primary model under `sets/<setKey>/`. `createModel` then derives
- * the colocated paths via `deriveColocatedBergamotVocabPaths`. This avoids a
- * redundant flat-cache copy and sidesteps the dedup edge case in QVAC-18420
- * where two directions of a bidirectional pair ship the same vocab blob under
- * distinct registry paths and only one survives sha256 dedup.
- */
-export declare function resolveBergamotVocab(nmtConfig: NmtConfig, ctx: ResolveContext, srcVocabSrc: ModelSrcInput | undefined, dstVocabSrc: ModelSrcInput | undefined, pivotModel?: PivotModelConfig): Promise<ResolveResult<Record<string, unknown>>>;
-//# sourceMappingURL=resolve-vocab.d.ts.map

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

@@ -1,114 +0,0 @@
-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`
-        };
-    }
-    const sharedVocab = `${basePath}vocab.${langPair}.spm`;
-    return { srcVocabSrc: sharedVocab, dstVocabSrc: sharedVocab };
-}
-export function deriveBergamotVocabSources(modelSrc) {
-    const match = modelSrc.match(/^pear:\/\/([a-f0-9]+)\/model\.([a-z]+)\.intgemm\.alphas\.bin$/);
-    if (!match?.[1] || !match[2])
-        return null;
-    const basePath = `pear://${match[1]}/`;
-    const langPair = match[2];
-    return buildBergamotVocabSources(basePath, langPair);
-}
-export function deriveBergamotRegistryVocabSources(modelSrc) {
-    const match = modelSrc.match(/^(registry:\/\/.+\/)model\.([a-z]+)\.intgemm\.alphas\.bin$/);
-    if (!match?.[1] || !match[2])
-        return null;
-    const basePath = match[1];
-    const langPair = match[2];
-    return buildBergamotVocabSources(basePath, langPair);
-}
-/**
- * Resolves Bergamot vocab sources to absolute filesystem paths via the SDK
- * resolver context, optionally including a pivot model.
- *
- * For `registry://` sources with auto-derived vocabs, this skips per-vocab
- * resolution because the companion-set download already colocates the vocabs
- * next to the primary model under `sets/<setKey>/`. `createModel` then derives
- * the colocated paths via `deriveColocatedBergamotVocabPaths`. This avoids a
- * redundant flat-cache copy and sidesteps the dedup edge case in QVAC-18420
- * where two directions of a bidirectional pair ship the same vocab blob under
- * distinct registry paths and only one survives sha256 dedup.
- */
-export async function resolveBergamotVocab(nmtConfig, ctx, srcVocabSrc, dstVocabSrc, pivotModel) {
-    let srcSrc = srcVocabSrc;
-    let dstSrc = dstVocabSrc;
-    if (!srcSrc || !dstSrc) {
-        const derived = ctx.modelSrc.startsWith('pear://')
-            ? deriveBergamotVocabSources(ctx.modelSrc)
-            : ctx.modelSrc.startsWith('registry://')
-                ? deriveBergamotRegistryVocabSources(ctx.modelSrc)
-                : null;
-        if (derived) {
-            srcSrc = srcSrc ?? derived.srcVocabSrc;
-            dstSrc = dstSrc ?? derived.dstVocabSrc;
-        }
-    }
-    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.');
-    }
-    if (!pivotModel) {
-        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)
-        ]);
-        return {
-            config: nmtConfig,
-            artifacts: { srcVocabPath, dstVocabPath }
-        };
-    }
-    let pivotSrcSrc = pivotModel.srcVocabSrc;
-    let pivotDstSrc = pivotModel.dstVocabSrc;
-    if (!pivotSrcSrc || !pivotDstSrc) {
-        const pivotDerived = pivotModel.modelSrc.startsWith('pear://')
-            ? deriveBergamotVocabSources(pivotModel.modelSrc)
-            : pivotModel.modelSrc.startsWith('registry://')
-                ? deriveBergamotRegistryVocabSources(pivotModel.modelSrc)
-                : null;
-        if (pivotDerived) {
-            pivotSrcSrc = pivotSrcSrc ?? pivotDerived.srcVocabSrc;
-            pivotDstSrc = pivotDstSrc ?? pivotDerived.dstVocabSrc;
-        }
-    }
-    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.');
-    }
-    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) {
-        const pivotModelPath = await ctx.resolveModelPath(pivotModel.modelSrc);
-        return { config: nmtConfig, artifacts: { pivotModelPath } };
-    }
-    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)
-    ]);
-    return {
-        config: nmtConfig,
-        artifacts: {
-            srcVocabPath,
-            dstVocabPath,
-            pivotSrcVocabPath,
-            pivotDstVocabPath,
-            pivotModelPath
-        }
-    };
-}

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

@@ -1,134 +0,0 @@
-import { type ParakeetConfig, type CreateModelParams, type PluginModelResult, type ResolveResult } from '../../../../schemas/index.js';
-export declare const parakeetPlugin: {
-    modelType: "parakeet-transcription";
-    displayName: string;
-    addonPackage: "@qvac/asr-ggml";
-    loadConfigSchema: import("zod").ZodObject<{
-        [x: string]: import("zod").ZodOptional<import("zod").ZodUnknown>;
-    }, import("zod/v4/core").$strict>;
-    resolveConfig(cfg: ParakeetConfig): Promise<ResolveResult<ParakeetConfig>>;
-    createModel(params: CreateModelParams): PluginModelResult;
-    handlers: {
-        transcribe: import("../../../../schemas/index.js").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;
-            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-                type: import("zod").ZodLiteral<"filePath">;
-                value: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>], "type">;
-            type: import("zod").ZodLiteral<"transcribe">;
-            requestId: import("zod").ZodOptional<import("zod").ZodString>;
-        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-            text: import("zod").ZodOptional<import("zod").ZodString>;
-            done: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            stats: import("zod").ZodOptional<import("zod").ZodObject<{
-                audioDuration: import("zod").ZodOptional<import("zod").ZodNumber>;
-                realTimeFactor: import("zod").ZodOptional<import("zod").ZodNumber>;
-                tokensPerSecond: import("zod").ZodOptional<import("zod").ZodNumber>;
-                totalTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
-                totalSegments: import("zod").ZodOptional<import("zod").ZodNumber>;
-                whisperEncodeTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                whisperDecodeTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                encoderTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                decoderTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                melSpecTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                backendDevice: import("zod").ZodOptional<import("zod").ZodNumber>;
-                backendId: import("zod").ZodOptional<import("zod").ZodNumber>;
-                gpuUnsupported: import("zod").ZodOptional<import("zod").ZodNumber>;
-                gpuMemTotalMb: import("zod").ZodOptional<import("zod").ZodNumber>;
-                gpuMemFreeMb: 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>>;
-            vad: import("zod").ZodOptional<import("zod").ZodObject<{
-                speaking: import("zod").ZodBoolean;
-                probability: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>>;
-            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").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.js").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">;
-            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>;
-            done: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            stats: import("zod").ZodOptional<import("zod").ZodObject<{
-                audioDuration: import("zod").ZodOptional<import("zod").ZodNumber>;
-                realTimeFactor: import("zod").ZodOptional<import("zod").ZodNumber>;
-                tokensPerSecond: import("zod").ZodOptional<import("zod").ZodNumber>;
-                totalTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
-                totalSegments: import("zod").ZodOptional<import("zod").ZodNumber>;
-                whisperEncodeTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                whisperDecodeTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                encoderTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                decoderTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                melSpecTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                backendDevice: import("zod").ZodOptional<import("zod").ZodNumber>;
-                backendId: import("zod").ZodOptional<import("zod").ZodNumber>;
-                gpuUnsupported: import("zod").ZodOptional<import("zod").ZodNumber>;
-                gpuMemTotalMb: import("zod").ZodOptional<import("zod").ZodNumber>;
-                gpuMemFreeMb: 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>>;
-            vad: import("zod").ZodOptional<import("zod").ZodObject<{
-                speaking: import("zod").ZodBoolean;
-                probability: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>>;
-            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").ZodObject<{
-                source: import("zod").ZodLiteral<"parakeet">;
-            }, import("zod/v4/core").$strip>], "source">>>;
-            type: import("zod").ZodLiteral<"transcribeStream">;
-        }, import("zod/v4/core").$strip>>;
-    };
-    logging: {
-        module: import("@qvac/asr-ggml/addonLogging").AddonLogging;
-        namespace: "@qvac/asr-ggml";
-    };
-};
-//# sourceMappingURL=plugin.d.ts.map

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

@@ -1,141 +0,0 @@
-import asrAddonLogging from '@qvac/asr-ggml/addonLogging';
-import ASRGgml from '@qvac/asr-ggml';
-import { definePlugin, defineHandler, defineDuplexHandler, transcribeRequestSchema, transcribeResponseSchema, transcribeStreamRequestSchema, transcribeStreamResponseSchema, ModelType, parakeetLoadConfigSchema, LEGACY_PARAKEET_ONNX_MODEL_CONFIG_FIELDS, ADDON_ASR } from '../../../../schemas/index.js';
-import { ModelLoadFailedError, TranscriptionFailedError, LegacyParakeetModelDeprecatedError } from '../../../../utils/errors-server.js';
-import { transcribe, transcribeStream } from '../../../../server/bare/ops/transcribe.js';
-import { attachModelExecutionMs } from '../../../../profiling/model-execution.js';
-import { buildParakeetEngineConfig } from '../../../../server/bare/plugins/asr-ggml/config.js';
-import { createAsrModelLogger } from '../../../../server/bare/plugins/asr-ggml/logging.js';
-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);
-    }
-    return Promise.resolve({ config: cfg });
-}
-function createParakeetModel(params) {
-    const config = (params.modelConfig ?? {});
-    const modelPath = params.modelPath;
-    if (!modelPath) {
-        throw new ModelLoadFailedError('Parakeet requires a GGUF model source');
-    }
-    const logger = createAsrModelLogger(params.modelId, ModelType.parakeetTranscription);
-    const model = new ASRGgml({
-        files: { model: modelPath },
-        config: buildParakeetEngineConfig(config),
-        enableStats: true,
-        logger
-    });
-    return { model };
-}
-export const parakeetPlugin = definePlugin({
-    modelType: ModelType.parakeetTranscription,
-    displayName: 'Parakeet (NVIDIA NeMo GGML)',
-    addonPackage: ADDON_ASR,
-    loadConfigSchema: parakeetLoadConfigSchema,
-    resolveConfig(cfg) {
-        return resolveParakeetConfig(cfg);
-    },
-    createModel(params) {
-        return createParakeetModel(params);
-    },
-    handlers: {
-        transcribe: defineHandler({
-            requestSchema: transcribeRequestSchema,
-            responseSchema: transcribeResponseSchema,
-            streaming: 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.`);
-                }
-                const stream = transcribe({
-                    modelId: request.modelId,
-                    audioChunk: request.audioChunk,
-                    prompt: request.prompt
-                }, request.requestId);
-                try {
-                    let result = await stream.next();
-                    while (!result.done) {
-                        yield {
-                            type: 'transcribe',
-                            text: result.value
-                        };
-                        result = await stream.next();
-                    }
-                    const { modelExecutionMs, stats } = result.value;
-                    yield attachModelExecutionMs({
-                        type: 'transcribe',
-                        text: '',
-                        done: true,
-                        ...(stats && { stats })
-                    }, modelExecutionMs);
-                }
-                finally {
-                    await stream.return?.(undefined);
-                }
-            }
-        }),
-        transcribeStream: defineDuplexHandler({
-            requestSchema: transcribeStreamRequestSchema,
-            responseSchema: transcribeStreamResponseSchema,
-            streaming: true,
-            duplex: true,
-            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);
-                try {
-                    let result = await iterator.next();
-                    while (!result.done) {
-                        const value = result.value;
-                        if (typeof value === 'object' && value !== null && 'type' in value) {
-                            if (value.type === 'endOfTurn') {
-                                yield {
-                                    type: 'transcribeStream',
-                                    endOfTurn: { source: 'parakeet' }
-                                };
-                            }
-                            result = await iterator.next();
-                            continue;
-                        }
-                        yield {
-                            type: 'transcribeStream',
-                            text: value
-                        };
-                        result = await iterator.next();
-                    }
-                    const { modelExecutionMs, stats } = result.value;
-                    yield attachModelExecutionMs({
-                        type: 'transcribeStream',
-                        text: '',
-                        done: true,
-                        ...(stats && { stats })
-                    }, modelExecutionMs);
-                }
-                finally {
-                    await iterator.return?.(undefined);
-                }
-            }
-        })
-    },
-    logging: {
-        module: asrAddonLogging,
-        namespace: ADDON_ASR
-    }
-});

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

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

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

@@ -1,63 +0,0 @@
-import { getModel } from '../../../../../server/bare/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_images = request.init_images
-        ? request.init_images.map((b64) => Buffer.from(b64, 'base64'))
-        : undefined;
-    const response = await model.run({
-        prompt: request.prompt,
-        negative_prompt: request.negative_prompt,
-        width: request.width,
-        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,
-        seed: request.seed,
-        batch_count: request.batch_count,
-        vae_tiling: request.vae_tiling,
-        cache_preset: request.cache_preset,
-        init_image,
-        init_images,
-        increase_ref_index: request.increase_ref_index,
-        auto_resize_ref_image: request.auto_resize_ref_image,
-        strength: request.strength,
-        lora: request.lora,
-        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++
-            };
-        }
-        else if (typeof chunk === 'string') {
-            try {
-                const tick = JSON.parse(chunk);
-                if ('step' in tick) {
-                    yield {
-                        type: 'diffusionStream',
-                        step: tick['step'],
-                        totalSteps: tick['total'],
-                        elapsedMs: tick['elapsed_ms']
-                    };
-                }
-            }
-            catch {
-                // Non-JSON string output — skip
-            }
-        }
-    }
-    const responseWithStats = response;
-    yield {
-        type: 'diffusionStream',
-        done: true,
-        stats: responseWithStats.stats ?? undefined
-    };
-}

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

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