@qvac/sdk 0.18.2 → 0.19.0

package/dist/server/bare/ops/load-model.js

@@ -1,82 +0,0 @@
-import { loadModelServerParamsSchema, normalizeModelType } from '../../../schemas/index.js';
-import { nowMs } from '../../../profiling/clock.js';
-import { forwardBackendDiagnostics } from '../../../profiling/backend-diagnostics.js';
-import { isModelLoaded, registerModel } from '../../../server/bare/registry/model-registry.js';
-import { startLogBuffering, stopLogBufferingWithTimeout } from '../../../server/bare/registry/logging-stream-registry.js';
-import { detectShardedModel, generateShardFilenames, validateShardedModelCache } from '../../../server/utils/index.js';
-import { PluginNotFoundError, ModelFileNotFoundError, ModelFileNotFoundInDirError, ModelFileLocateFailedError } from '../../../utils/errors-server.js';
-import { getPlugin } from '../../../server/plugins/index.js';
-import { promises as fsPromises } from 'bare-fs';
-import path from 'bare-path';
-import { getServerLogger } from '../../../logging/index.js';
-const logger = getServerLogger();
-export async function loadModel(params, options) {
-    const { modelId, modelPath, options: modelOptions, artifacts, modelName } = loadModelServerParamsSchema.parse(params);
-    const { modelConfig, modelType: rawModelType } = modelOptions;
-    // Normalize modelType to canonical form (handles aliases and custom types)
-    const modelType = normalizeModelType(rawModelType);
-    // Check if model is already loaded
-    if (isModelLoaded(modelId)) {
-        logger.info(`${modelType} model ${modelId} is already loaded`);
-        return {};
-    }
-    // Detect if sharded model
-    const modelFileName = path.basename(modelPath);
-    const shardInfo = detectShardedModel(modelFileName);
-    const isShardedModel = shardInfo.isSharded;
-    const plugin = getPlugin(modelType);
-    if (!plugin) {
-        throw new PluginNotFoundError(modelType);
-    }
-    if (isShardedModel) {
-        // For sharded models, validate all shards and tensors.txt exist
-        const shardDir = path.dirname(modelPath);
-        const isValid = await validateShardedModelCache(shardDir, modelFileName);
-        if (!isValid) {
-            const numberedShards = generateShardFilenames(modelFileName);
-            throw new ModelFileNotFoundError(`Missing shards or ${shardInfo.baseFilename}.tensors.txt. Expected ${numberedShards.length} shard files + tensors.txt in ${shardDir}`);
-        }
-    }
-    else if (!plugin.skipPrimaryModelPathValidation) {
-        // For non-sharded models, validate single file exists
-        try {
-            const modelDir = path.dirname(modelPath);
-            const modelFile = path.basename(modelPath);
-            const files = (await fsPromises.readdir(modelDir));
-            if (!files.includes(modelFile)) {
-                throw new ModelFileNotFoundInDirError(modelFile, modelDir, modelType);
-            }
-        }
-        catch (error) {
-            logger.error(`Error reading ${modelType} model directory:`, error instanceof Error ? error.message : String(error));
-            throw new ModelFileLocateFailedError(modelType, modelPath, error);
-        }
-    }
-    logger.info(`${modelType}: Loading model ${modelId}...`);
-    startLogBuffering(modelId);
-    try {
-        const initStart = options?.collectTiming ? nowMs() : 0;
-        const result = plugin.createModel({
-            modelId,
-            modelPath,
-            modelConfig: modelConfig,
-            modelName,
-            artifacts
-        });
-        await result.model.load(false);
-        const modelInitializationTimeMs = options?.collectTiming ? nowMs() - initStart : undefined;
-        logger.info(`${modelType} model ${modelId} loaded`);
-        registerModel(modelId, {
-            model: result.model,
-            path: modelPath,
-            config: modelConfig,
-            modelType: modelType,
-            name: modelName
-        });
-        const loadResult = modelInitializationTimeMs !== undefined ? { timing: { modelInitializationTimeMs } } : {};
-        return forwardBackendDiagnostics(loadResult, result);
-    }
-    finally {
-        stopLogBufferingWithTimeout(modelId);
-    }
-}

package/dist/server/bare/ops/transcribe.d.ts

@@ -1,20 +0,0 @@
-import { type TranscribeParams, type TranscribeSegment, type TranscribeStats, type TranscribeStreamEvent, type ParakeetStreamingRunConfig } from '../../../schemas/index.js';
-import { assertMetadataSupported, toTranscribeSegment, type WhisperAddonSegment } from '../../../server/bare/utils/transcribe-metadata.js';
-export { assertMetadataSupported, toTranscribeSegment, type WhisperAddonSegment };
-type TranscribeReturn = {
-    modelExecutionMs: number;
-    stats?: TranscribeStats;
-};
-export declare function transcribe(params: TranscribeParams & {
-    metadata: true;
-}, requestId?: string): AsyncGenerator<TranscribeSegment, TranscribeReturn, void>;
-export declare function transcribe(params: TranscribeParams, requestId?: string): AsyncGenerator<string, TranscribeReturn, void>;
-export interface TranscribeStreamOpts {
-    emitVadEvents?: boolean;
-    endOfTurnSilenceMs?: number;
-    vadRunIntervalMs?: number;
-    parakeetStreamingConfig?: ParakeetStreamingRunConfig;
-}
-export declare function transcribeStream(modelId: string, audioInputStream: AsyncIterable<Buffer>, prompt: string | undefined, metadata: true, opts?: TranscribeStreamOpts, requestId?: string): AsyncGenerator<TranscribeSegment | TranscribeStreamEvent, TranscribeReturn, void>;
-export declare function transcribeStream(modelId: string, audioInputStream: AsyncIterable<Buffer>, prompt?: string, metadata?: boolean, opts?: TranscribeStreamOpts, requestId?: string): AsyncGenerator<string | TranscribeStreamEvent, TranscribeReturn, void>;
-//# sourceMappingURL=transcribe.d.ts.map

package/dist/server/bare/ops/transcribe.js

@@ -1,349 +0,0 @@
-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 { getModel, getModelConfig, getModelEntry } from '../../../server/bare/registry/model-registry.js';
-import { ModelType } from '../../../schemas/index.js';
-import { createAudioStream } from '../../../server/bare/utils/audio-input.js';
-import { getServerLogger } from '../../../logging/index.js';
-import { TranscriptionFailedError } from '../../../utils/errors-server.js';
-import { nowMs } from '../../../profiling/index.js';
-import { buildStreamResult } from '../../../profiling/model-execution.js';
-import { assertMetadataSupported, toTranscribeSegment } from '../../../server/bare/utils/transcribe-metadata.js';
-import { getRequestRegistry, withRequestContext } from '../../../server/bare/runtime/index.js';
-import { generateServerRequestId } from '../../../server/bare/runtime/request-id.js';
-import { isEndOfTurnEvent, isVadEvent, toEndOfTurnEvent, toVadStateEvent } from '../../../server/bare/utils/asr-events.js';
-import { buildWhisperReloadConfig } from '../../../server/bare/plugins/asr-ggml/config.js';
-export { assertMetadataSupported, toTranscribeSegment };
-function hasRunStreaming(model) {
-    return 'runStreaming' in model && typeof model.runStreaming === 'function';
-}
-const SILENCE_MARKERS = {
-    [ModelType.whispercppTranscription]: '[BLANK_AUDIO]',
-    [ModelType.parakeetTranscription]: '[No speech detected]'
-};
-function getEngineModelType(modelId) {
-    const entry = getModelEntry(modelId);
-    if (!entry || entry.isDelegated)
-        return '';
-    return entry.local.modelType;
-}
-function getAudioFormat(modelId, engineType) {
-    if (engineType === ModelType.whispercppTranscription) {
-        const config = getModelConfig(modelId);
-        return config.audio_format || 's16le';
-    }
-    return 's16le';
-}
-async function applyPrompt(modelId, prompt, engineType) {
-    if (engineType !== ModelType.whispercppTranscription || !prompt) {
-        return null;
-    }
-    const model = getModel(modelId);
-    if (typeof model.reload !== 'function')
-        return null;
-    const originalConfig = getModelConfig(modelId);
-    await model.reload(buildWhisperReloadConfig({ ...originalConfig, initial_prompt: prompt }));
-    return originalConfig;
-}
-async function restorePrompt(modelId, originalConfig) {
-    const model = getModel(modelId);
-    if (typeof model.reload !== 'function')
-        return;
-    await model.reload(buildWhisperReloadConfig({ ...originalConfig, initial_prompt: '' }));
-}
-function mapTranscribeStats(stats) {
-    return {
-        ...(stats?.audioDurationMs !== undefined && {
-            audioDuration: stats.audioDurationMs
-        }),
-        ...(stats?.realTimeFactor !== undefined && {
-            realTimeFactor: stats.realTimeFactor
-        }),
-        ...(stats?.tokensPerSecond !== undefined && {
-            tokensPerSecond: stats.tokensPerSecond
-        }),
-        ...(stats?.totalTokens !== undefined && {
-            totalTokens: stats.totalTokens
-        }),
-        ...(stats?.totalSegments !== undefined && {
-            totalSegments: stats.totalSegments
-        }),
-        ...(stats?.whisperEncodeMs !== undefined && {
-            whisperEncodeTime: stats.whisperEncodeMs
-        }),
-        ...(stats?.whisperDecodeMs !== undefined && {
-            whisperDecodeTime: stats.whisperDecodeMs
-        }),
-        ...(stats?.encoderMs !== undefined && {
-            encoderTime: stats.encoderMs
-        }),
-        ...(stats?.decoderMs !== undefined && {
-            decoderTime: stats.decoderMs
-        }),
-        ...(stats?.melSpecMs !== undefined && {
-            melSpecTime: stats.melSpecMs
-        }),
-        ...(stats?.backendDevice !== undefined && {
-            backendDevice: stats.backendDevice
-        }),
-        ...(stats?.backendId !== undefined && {
-            backendId: stats.backendId
-        }),
-        ...(stats?.gpuUnsupported !== undefined && {
-            gpuUnsupported: stats.gpuUnsupported
-        }),
-        ...(stats?.gpuMemTotalMb !== undefined && {
-            gpuMemTotalMb: stats.gpuMemTotalMb
-        }),
-        ...(stats?.gpuMemFreeMb !== undefined && {
-            gpuMemFreeMb: stats.gpuMemFreeMb
-        })
-    };
-}
-export async function* transcribe(params, requestId) {
-    const env_1 = { stack: [], error: void 0, hasError: false };
-    try {
-        const { modelId, metadata } = params;
-        // Open a request-scoped lifecycle. The registry routes
-        // `cancel({ requestId })` and `cancel({ modelId, kind: "transcribe" })`
-        // through this context. Falls back to a server-generated id if the
-        // client didn't send one.
-        const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
-            requestId: requestId ?? generateServerRequestId(),
-            kind: 'transcribe',
-            modelId
-        }), true);
-        const requestLogger = withRequestContext(getServerLogger(), ctx);
-        const engineType = getEngineModelType(modelId);
-        assertMetadataSupported(modelId, engineType, metadata);
-        const silenceMarker = SILENCE_MARKERS[engineType] ?? '';
-        const audioFormat = getAudioFormat(modelId, engineType);
-        const originalConfig = await applyPrompt(modelId, params.prompt, engineType);
-        if (originalConfig) {
-            // `restorePrompt` runs on every exit path — happy, throw, cancel —
-            // via the scope. LIFO unwinding pairs with the addon-cancel detach
-            // below.
-            ctx.scope.defer(() => restorePrompt(modelId, originalConfig));
-        }
-        const model = getModel(modelId);
-        // Hard-cancel wiring: whisper.cpp / parakeet expose model-wide
-        // `addon.cancel()`. The listener forwards an abort so the
-        // currently-running transcription stops decoding ASAP. The
-        // `if (ctx.signal.aborted) break` guard inside the iterate loop is
-        // the soft-cancel safety net for the case where the abort fires
-        // between the addon flag flipping and the iterator's next pull.
-        const onAbort = () => {
-            const addon = model.addon;
-            if (addon?.cancel) {
-                addon.cancel.call(addon).catch((err) => {
-                    requestLogger.warn(`[cancel] addon.cancel() rejected during abort for modelId=${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 audioStream = await createAudioStream(params.audioChunk, audioFormat);
-        const modelStart = nowMs();
-        const response = (await model.run(audioStream));
-        for await (const output of response.iterate()) {
-            if (ctx.signal.aborted)
-                break;
-            requestLogger.debug('Streaming Transcription Update:', output);
-            const chunks = (Array.isArray(output) ? output : [output]);
-            if (metadata) {
-                for (const chunk of chunks) {
-                    if (!chunk.text)
-                        continue;
-                    if (silenceMarker && chunk.text.includes(silenceMarker))
-                        continue;
-                    yield toTranscribeSegment(chunk);
-                }
-                continue;
-            }
-            const text = chunks
-                .filter((chunk) => !silenceMarker || !chunk.text.includes(silenceMarker))
-                .map((chunk) => chunk.text)
-                .join('');
-            if (text.trim()) {
-                yield text;
-            }
-        }
-        const modelExecutionMs = nowMs() - modelStart;
-        return buildStreamResult(modelExecutionMs, mapTranscribeStats(response.stats));
-    }
-    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;
-    }
-}
-function buildRunStreamingOpts(engineType, opts) {
-    if (engineType === ModelType.parakeetTranscription) {
-        return opts?.parakeetStreamingConfig;
-    }
-    const runOpts = {};
-    if (opts?.emitVadEvents)
-        runOpts.emitVadEvents = true;
-    if (opts?.endOfTurnSilenceMs !== undefined) {
-        runOpts.endOfTurnSilenceMs = opts.endOfTurnSilenceMs;
-    }
-    if (opts?.vadRunIntervalMs !== undefined) {
-        runOpts.vadRunIntervalMs = opts.vadRunIntervalMs;
-    }
-    return runOpts;
-}
-export async function* transcribeStream(modelId, audioInputStream, prompt, metadata, opts, requestId) {
-    const env_2 = { stack: [], error: void 0, hasError: false };
-    try {
-        // Same `kind: "transcribe"` as the unary variant — the registry
-        // doesn't distinguish streaming vs non-streaming variants of the same
-        // operation, so `cancel({ modelId, kind: "transcribe" })` cancels
-        // either shape.
-        const ctx = __addDisposableResource(env_2, await getRequestRegistry().begin({
-            requestId: requestId ?? generateServerRequestId(),
-            kind: 'transcribe',
-            modelId
-        }), true);
-        const requestLogger = withRequestContext(getServerLogger(), ctx);
-        const engineType = getEngineModelType(modelId);
-        assertMetadataSupported(modelId, engineType, metadata);
-        const silenceMarker = SILENCE_MARKERS[engineType] ?? '';
-        const originalConfig = await applyPrompt(modelId, prompt, engineType);
-        if (originalConfig) {
-            ctx.scope.defer(() => restorePrompt(modelId, originalConfig));
-        }
-        const model = getModel(modelId);
-        if (!hasRunStreaming(model)) {
-            throw new TranscriptionFailedError(`Model ${modelId} does not support streaming transcription`);
-        }
-        const onAbort = () => {
-            const addon = model.addon;
-            if (addon?.cancel) {
-                addon.cancel.call(addon).catch((err) => {
-                    requestLogger.warn(`[cancel] addon.cancel() rejected during abort for modelId=${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 runOpts = buildRunStreamingOpts(engineType, opts);
-        const modelStart = nowMs();
-        const response = await model.runStreaming(audioInputStream, runOpts);
-        for await (const output of response.iterate()) {
-            if (ctx.signal.aborted)
-                break;
-            requestLogger.debug('Live Transcription Update:', output);
-            if (!Array.isArray(output)) {
-                if (isVadEvent(output)) {
-                    yield {
-                        type: 'vad',
-                        ...toVadStateEvent(output)
-                    };
-                    continue;
-                }
-                if (isEndOfTurnEvent(output)) {
-                    const event = toEndOfTurnEvent(output);
-                    if (event) {
-                        yield {
-                            type: 'endOfTurn',
-                            ...event
-                        };
-                    }
-                    continue;
-                }
-                yield* emitSegment(output, metadata, silenceMarker);
-                continue;
-            }
-            for (const segment of output) {
-                yield* emitSegment(segment, metadata, silenceMarker);
-            }
-        }
-        await response.await();
-        const modelExecutionMs = nowMs() - modelStart;
-        return buildStreamResult(modelExecutionMs, mapTranscribeStats(response.stats));
-    }
-    catch (e_2) {
-        env_2.error = e_2;
-        env_2.hasError = true;
-    }
-    finally {
-        const result_2 = __disposeResources(env_2);
-        if (result_2)
-            await result_2;
-    }
-}
-function* emitSegment(segment, metadata, silenceMarker) {
-    if (!segment.text) {
-        return;
-    }
-    if (silenceMarker && segment.text.includes(silenceMarker)) {
-        return;
-    }
-    if (metadata) {
-        yield toTranscribeSegment(segment);
-    }
-    else if (segment.text.trim()) {
-        yield segment.text;
-    }
-}

package/dist/server/bare/ops/translate-stats.d.ts

@@ -1,5 +0,0 @@
-import type { TranslationStats } from '../../../schemas/index.js';
-import type { NmtStats } from '../../../server/bare/types/addon-responses.js';
-export declare const NMT_SECONDS_TO_MS = 1000;
-export declare function buildNmtTranslationStats(stats: Partial<NmtStats> | undefined): TranslationStats;
-//# sourceMappingURL=translate-stats.d.ts.map

package/dist/server/bare/ops/translate-stats.js

@@ -1,11 +0,0 @@
-export const NMT_SECONDS_TO_MS = 1000;
-export function buildNmtTranslationStats(stats) {
-    return {
-        ...(stats?.totalTime !== undefined && { totalTime: stats.totalTime * NMT_SECONDS_TO_MS }),
-        ...(stats?.totalTokens !== undefined && { totalTokens: stats.totalTokens }),
-        ...(stats?.decodeTime !== undefined && { decodeTime: stats.decodeTime * NMT_SECONDS_TO_MS }),
-        ...(stats?.encodeTime !== undefined && { encodeTime: stats.encodeTime * NMT_SECONDS_TO_MS }),
-        ...(stats?.TPS !== undefined && { tokensPerSecond: stats.TPS }),
-        ...(stats?.TTFT !== undefined && { timeToFirstToken: stats.TTFT })
-    };
-}

package/dist/server/bare/ops/translate.d.ts

@@ -1,8 +0,0 @@
-import { type TranslateParams, type TranslationStats } from '../../../schemas/index.js';
-export declare function getLanguage(code: string | undefined): string;
-export declare function isAfrican(code: string | undefined): boolean;
-export declare function translate(params: TranslateParams, requestId?: string): AsyncGenerator<string, {
-    modelExecutionMs: number;
-    stats?: TranslationStats;
-}, unknown>;
-//# sourceMappingURL=translate.d.ts.map