@qvac/sdk 0.16.0 → 0.17.1

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

@@ -50,16 +50,18 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { getModel, getModelConfig, getModelEntry } from '../registry/model-registry.js';
+import { getModel, getModelConfig, getModelEntry } from '../../../server/bare/registry/model-registry.js';
 import { ModelType } from '../../../schemas/index.js';
-import { createAudioStream } from '../utils/audio-input.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 '../utils/transcribe-metadata.js';
-import { getRequestRegistry, withRequestContext } from '../runtime/index.js';
-import { generateServerRequestId } from '../runtime/request-id.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';
@@ -89,25 +91,14 @@ async function applyPrompt(modelId, prompt, engineType) {
     if (typeof model.reload !== 'function')
         return null;
     const originalConfig = getModelConfig(modelId);
-    const updatedConfig = { ...originalConfig, initial_prompt: prompt };
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const { contextParams: _, miscConfig, ...whisperParams } = updatedConfig;
-    await model.reload({
-        whisperConfig: whisperParams,
-        ...(miscConfig && { miscConfig })
-    });
+    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;
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const { contextParams: _, miscConfig, ...whisperParams } = originalConfig;
-    await model.reload({
-        whisperConfig: { ...whisperParams, initial_prompt: '' },
-        ...(miscConfig && { miscConfig })
-    });
+    await model.reload(buildWhisperReloadConfig({ ...originalConfig, initial_prompt: '' }));
 }
 export async function* transcribe(params, requestId) {
     const env_1 = { stack: [], error: void 0, hasError: false };
@@ -301,22 +292,20 @@ export async function* transcribeStream(modelId, audioInputStream, prompt, metad
                 break;
             requestLogger.debug('Live Transcription Update:', output);
             if (!Array.isArray(output)) {
-                if ('type' in output) {
-                    if (output.type === 'vad') {
-                        yield {
-                            type: 'vad',
-                            speaking: output.speaking,
-                            probability: output.probability
-                        };
-                        continue;
-                    }
-                    if (output.type === 'endOfTurn') {
+                if (isVadEvent(output)) {
+                    yield {
+                        type: 'vad',
+                        ...toVadStateEvent(output)
+                    };
+                    continue;
+                }
+                if (isEndOfTurnEvent(output)) {
+                    const event = toEndOfTurnEvent(output);
+                    if (event) {
                         yield {
                             type: 'endOfTurn',
-                            source: 'whisper',
-                            silenceDurationMs: output.silenceDurationMs
+                            ...event
                         };
-                        continue;
                     }
                     continue;
                 }
@@ -340,15 +329,9 @@ export async function* transcribeStream(modelId, audioInputStream, prompt, metad
 }
 function* emitSegment(segment, metadata, silenceMarker) {
     if (!segment.text) {
-        if (segment.isEndOfTurn) {
-            yield { type: 'endOfTurn', source: 'parakeet' };
-        }
         return;
     }
     if (silenceMarker && segment.text.includes(silenceMarker)) {
-        if (segment.isEndOfTurn) {
-            yield { type: 'endOfTurn', source: 'parakeet' };
-        }
         return;
     }
     if (metadata) {
@@ -357,7 +340,4 @@ function* emitSegment(segment, metadata, silenceMarker) {
     else if (segment.text.trim()) {
         yield segment.text;
     }
-    if (segment.isEndOfTurn) {
-        yield { type: 'endOfTurn', source: 'parakeet' };
-    }
 }

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

@@ -1,4 +1,4 @@
-import { type TranslateParams, type TranslationStats } from '../../../schemas/index';
+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, {

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

@@ -50,14 +50,14 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { getModelEntry } from '../registry/model-registry.js';
+import { getModelEntry } from '../../../server/bare/registry/model-registry.js';
 import { translateServerParamsSchema, normalizeModelType, ModelType, AFRICAN_LANGUAGES_MAP } from '../../../schemas/index.js';
 import { getLangName, detectOne } from '@qvac/langdetect-text';
 import { nowMs } from '../../../profiling/index.js';
 import { buildStreamResult } from '../../../profiling/model-execution.js';
 import { ModelIsDelegatedError, ModelNotFoundError, ModelTypeMismatchError, TranslationFailedError } from '../../../utils/errors-server.js';
-import { getRequestRegistry, withRequestContext } from '../runtime/index.js';
-import { generateServerRequestId } from '../runtime/request-id.js';
+import { getRequestRegistry, withRequestContext } from '../../../server/bare/runtime/index.js';
+import { generateServerRequestId } from '../../../server/bare/runtime/request-id.js';
 import { getServerLogger } from '../../../logging/index.js';
 export function getLanguage(code) {
     if (!code)
@@ -104,6 +104,7 @@ export async function* translate(params, requestId) {
         let from = isLlm ? params.from : undefined;
         const to = isLlm ? params.to : undefined;
         const context = isLlm ? params.context : undefined;
+        translateServerParamsSchema.parse(params);
         // Auto-detect the source language when the caller didn't pass `from` (LLM
         // only). This used to run in each client; moving it here gives every
         // language binding one detector instead of each shipping its own (lingua in
@@ -118,7 +119,6 @@ export async function* translate(params, requestId) {
             from = detected.code;
         }
         const afriquePrompt = isLlm && (isAfrican(from) || isAfrican(to));
-        translateServerParamsSchema.parse(params);
         const fromLanguage = getLanguage(from);
         const toLanguage = getLanguage(to);
         // Open a request-scoped lifecycle for both engine branches. LLM-
@@ -192,11 +192,7 @@ export async function* translate(params, requestId) {
         let response;
         if (canonicalModelType === ModelType.llamacppCompletion &&
             !shouldSkipPerCallSampling(entry.local.name)) {
-            // AnyModel.run is intentionally erased to a single-arg signature in the
-            // registry layer (Omit<BaseInference, "addon">). Re-narrow to the engine
-            // shape so we get the same typing as @qvac/llm-llamacpp.run().
-            const llmRun = model.run.bind(model);
-            response = await llmRun(input, {
+            response = await model.run(input, {
                 generationParams: LLM_TRANSLATE_GENERATION_PARAMS
             });
         }

package/dist/server/bare/ops/unload-model.d.ts

@@ -1,3 +1,3 @@
-import { type UnloadModelParams } from '../../../schemas/index';
+import { type UnloadModelParams } from '../../../schemas/index.js';
 export declare function unloadModel(params: UnloadModelParams): Promise<void>;
 //# sourceMappingURL=unload-model.d.ts.map

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

@@ -1,13 +1,13 @@
 import { promises as fsPromises } from 'bare-fs';
 import path from 'bare-path';
-import { unregisterModel } from '../registry/model-registry.js';
-import { unregisterAllLoggingStreams } from '../registry/logging-stream-registry.js';
-import { clearFinetuneRuntimeState } from '../plugins/llamacpp-completion/ops/finetune.js';
+import { unregisterModel } from '../../../server/bare/registry/model-registry.js';
+import { unregisterAllLoggingStreams } from '../../../server/bare/registry/logging-stream-registry.js';
+import { clearFinetuneRuntimeState } from '../../../server/bare/plugins/llamacpp-completion/ops/finetune.js';
 import { unregisterAddonLogger, getServerLogger } from '../../../logging/index.js';
 import { unloadModelParamsSchema } from '../../../schemas/index.js';
 import { ModelNotLoadedError } from '../../../utils/errors-server.js';
-import { detectShardedModel } from '../../utils/index.js';
-import { getClearStorageTarget } from '../../utils/cache/paths.js';
+import { detectShardedModel } from '../../../server/utils/index.js';
+import { getClearStorageTarget } from '../../../server/utils/cache/paths.js';
 const logger = getServerLogger();
 export async function unloadModel(params) {
     const { modelId, clearStorage } = unloadModelParamsSchema.parse(params);

package/dist/server/bare/plugins/asr-ggml/config.d.ts

@@ -0,0 +1,32 @@
+import type ASRGgml from '@qvac/asr-ggml';
+import type { ParakeetConfig, WhisperConfig } from '../../../../schemas/index.js';
+export declare function buildWhisperEngineConfig(config: WhisperConfig): {
+    miscConfig?: {
+        [k: string]: unknown;
+    };
+    contextParams?: {
+        [k: string]: unknown;
+    };
+    engine: "whisper";
+    whisperConfig: ASRGgml.WhisperConfig;
+};
+export declare function buildParakeetEngineConfig(config: ParakeetConfig): {
+    engine: "parakeet";
+    parakeetConfig: {
+        [k: string]: unknown;
+    };
+};
+export declare function buildWhisperReloadConfig(config: WhisperConfig): {
+    miscConfig?: {
+        [k: string]: unknown;
+    };
+    whisperConfig: {
+        [k: string]: unknown;
+    };
+};
+export declare function buildParakeetReloadConfig(config: ParakeetConfig): {
+    parakeetConfig: {
+        [k: string]: unknown;
+    };
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/server/bare/plugins/asr-ggml/config.js

@@ -0,0 +1,46 @@
+function omitUndefined(config) {
+    return Object.fromEntries(Object.entries(config).filter(([, value]) => value !== undefined));
+}
+function buildWhisperConfig(config) {
+    const whisperConfig = omitUndefined(config);
+    delete whisperConfig['contextParams'];
+    delete whisperConfig['miscConfig'];
+    delete whisperConfig['vadModelSrc'];
+    const detectLanguage = whisperConfig['detect_language'];
+    delete whisperConfig['detect_language'];
+    if (detectLanguage === true) {
+        whisperConfig['language'] = 'auto';
+    }
+    return whisperConfig;
+}
+export function buildWhisperEngineConfig(config) {
+    const whisperConfig = buildWhisperConfig(config);
+    return {
+        engine: 'whisper',
+        whisperConfig: whisperConfig,
+        ...(config.contextParams && {
+            contextParams: omitUndefined(config.contextParams)
+        }),
+        ...(config.miscConfig && { miscConfig: omitUndefined(config.miscConfig) })
+    };
+}
+export function buildParakeetEngineConfig(config) {
+    return {
+        engine: 'parakeet',
+        parakeetConfig: omitUndefined(config)
+    };
+}
+export function buildWhisperReloadConfig(config) {
+    const whisperConfig = buildWhisperConfig(config);
+    return {
+        whisperConfig,
+        ...(config.miscConfig && {
+            miscConfig: omitUndefined(config.miscConfig)
+        })
+    };
+}
+export function buildParakeetReloadConfig(config) {
+    return {
+        parakeetConfig: omitUndefined(config)
+    };
+}

package/dist/server/bare/plugins/asr-ggml/logging.d.ts

@@ -0,0 +1,11 @@
+import type { ModelType } from '../../../../schemas/index.js';
+type AsrModelType = typeof ModelType.whispercppTranscription | typeof ModelType.parakeetTranscription;
+/**
+ * ASRGgml's native logger is process-global and cannot identify its originating
+ * model. Keep instance loggers on engine-specific namespaces so the logger
+ * passed to each ASRGgml instance remains isolated instead of subscribing both
+ * model streams to the shared native callback.
+ */
+export declare function createAsrModelLogger(modelId: string, modelType: AsrModelType): import("../../../../logging/index.js").Logger;
+export {};
+//# sourceMappingURL=logging.d.ts.map

package/dist/server/bare/plugins/asr-ggml/logging.js

@@ -0,0 +1,12 @@
+import { createStreamLogger, registerAddonLogger } from '../../../../logging/index.js';
+/**
+ * ASRGgml's native logger is process-global and cannot identify its originating
+ * model. Keep instance loggers on engine-specific namespaces so the logger
+ * passed to each ASRGgml instance remains isolated instead of subscribing both
+ * model streams to the shared native callback.
+ */
+export function createAsrModelLogger(modelId, modelType) {
+    const logger = createStreamLogger(modelId, modelType);
+    registerAddonLogger(modelId, modelType, logger);
+    return logger;
+}

package/dist/server/bare/plugins/audiogen-ggml/config.d.ts

@@ -0,0 +1,18 @@
+import { type ResolveContext } from '../../../../schemas/index.js';
+export declare function resolveAudioGenConfig(config: Record<string, unknown>, ctx: ResolveContext): Promise<{
+    config: {
+        useGPU?: boolean | undefined;
+        inferenceSteps?: number | undefined;
+        shift?: number | undefined;
+        nGpuLayers?: number | undefined;
+        threads?: number | undefined;
+        backendsDir?: string | undefined;
+    };
+    artifacts: {
+        textEncModelPath: string;
+        lmModelPath: string;
+        ditModelPath: string;
+        vaeModelPath: string;
+    };
+}>;
+//# sourceMappingURL=config.d.ts.map

package/dist/server/bare/plugins/audiogen-ggml/config.js

@@ -0,0 +1,23 @@
+import { audioGenConfigSchema } from '../../../../schemas/index.js';
+export async function resolveAudioGenConfig(config, ctx) {
+    const parsed = audioGenConfigSchema.parse(config);
+    const { textEncModelSrc, lmModelSrc, ditModelSrc, vaeModelSrc, ...runtimeConfig } = parsed;
+    // These four artifacts total several gigabytes. Resolving them concurrently
+    // splits bandwidth across independent registry streams and can make each one
+    // exceed the per-block stall timeout even while aggregate throughput is
+    // healthy. Resolve sequentially until model constants and config resolution
+    // can expose a companion set together with all four resolved artifact paths.
+    const textEncModelPath = await ctx.resolveModelPath(textEncModelSrc);
+    const lmModelPath = await ctx.resolveModelPath(lmModelSrc);
+    const ditModelPath = await ctx.resolveModelPath(ditModelSrc);
+    const vaeModelPath = await ctx.resolveModelPath(vaeModelSrc);
+    return {
+        config: runtimeConfig,
+        artifacts: {
+            textEncModelPath,
+            lmModelPath,
+            ditModelPath,
+            vaeModelPath
+        }
+    };
+}

package/dist/server/bare/plugins/audiogen-ggml/ops/audio-gen-stream.d.ts

@@ -0,0 +1,3 @@
+import { type AudioGenStreamRequest, type AudioGenStreamResponse } from '../../../../../schemas/audio-gen.js';
+export declare function audioGenStream(request: AudioGenStreamRequest): AsyncGenerator<AudioGenStreamResponse>;
+//# sourceMappingURL=audio-gen-stream.d.ts.map

package/dist/server/bare/plugins/audiogen-ggml/ops/audio-gen-stream.js

@@ -0,0 +1,162 @@
+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 { AudioGen } from '@qvac/audiogen-ggml';
+import { audioGenStatsSchema } from '../../../../../schemas/audio-gen.js';
+import { getServerLogger } from '../../../../../logging/index.js';
+import { getModel } from '../../../../../server/bare/registry/model-registry.js';
+import { getRequestRegistry, withRequestContext } from '../../../../../server/bare/runtime/index.js';
+import { generateServerRequestId } from '../../../../../server/bare/runtime/request-id.js';
+import { ModelOperationNotSupportedError } from '../../../../../utils/errors-server.js';
+export async function* audioGenStream(request) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
+            requestId: request.requestId ?? generateServerRequestId(),
+            kind: 'audiogen',
+            modelId: request.modelId
+        }), true);
+        const logger = withRequestContext(getServerLogger(), ctx);
+        const candidate = getModel(request.modelId);
+        if (!(candidate instanceof AudioGen)) {
+            throw new ModelOperationNotSupportedError(request.modelId, 'audiogen-ggml', 'audioGenStream', [], []);
+        }
+        const model = candidate;
+        // A queued request can resume from begin() already aborted. It never owned
+        // the model slot, so calling the model-scoped cancel here would interrupt
+        // the earlier same-model generation that still owns it.
+        if (Boolean(ctx.signal.aborted)) {
+            yield {
+                type: 'audioGenStream',
+                done: true,
+                stopReason: 'cancelled'
+            };
+            return;
+        }
+        let cancelPromise;
+        const onAbort = () => {
+            cancelPromise ??= model.cancel().catch((error) => {
+                logger.warn(`[cancel] model.cancel() rejected during abort for modelId=${request.modelId}: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        };
+        ctx.signal.addEventListener('abort', onAbort, { once: true });
+        if (ctx.signal.aborted)
+            onAbort();
+        ctx.scope.defer(async () => {
+            ctx.signal.removeEventListener('abort', onAbort);
+            await cancelPromise;
+        });
+        let response;
+        try {
+            if (!ctx.signal.aborted) {
+                response = await model.run(request.caption, {
+                    ...(request.lyrics !== undefined && { lyrics: request.lyrics }),
+                    ...(request.seed !== undefined && { seed: request.seed }),
+                    ...(request.vocalLanguage !== undefined && { vocalLanguage: request.vocalLanguage }),
+                    ...(request.bpm !== undefined && { bpm: request.bpm }),
+                    ...(request.keyscale !== undefined && { keyscale: request.keyscale }),
+                    ...(request.timesignature !== undefined && { timesignature: request.timesignature }),
+                    ...(request.duration !== undefined && { duration: request.duration })
+                });
+                for await (const chunk of response.iterate()) {
+                    if (ctx.signal.aborted)
+                        break;
+                    if ('progress' in chunk) {
+                        yield {
+                            type: 'audioGenStream',
+                            progress: chunk.progress,
+                            done: false
+                        };
+                        continue;
+                    }
+                    const pcm = new Uint8Array(chunk.outputArray.buffer, chunk.outputArray.byteOffset, chunk.outputArray.byteLength);
+                    yield {
+                        type: 'audioGenStream',
+                        data: Buffer.from(pcm).toString('base64'),
+                        sampleRate: chunk.sampleRate,
+                        channels: chunk.channels,
+                        bitsPerSample: Int16Array.BYTES_PER_ELEMENT * 8,
+                        done: false
+                    };
+                }
+            }
+        }
+        catch (error) {
+            if (!ctx.signal.aborted)
+                throw error;
+        }
+        if (ctx.signal.aborted) {
+            yield {
+                type: 'audioGenStream',
+                done: true,
+                stopReason: 'cancelled'
+            };
+            return;
+        }
+        const stats = audioGenStatsSchema.parse(await response.await());
+        yield {
+            type: 'audioGenStream',
+            done: true,
+            stopReason: 'completed',
+            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;
+    }
+}