@qvac/sdk 0.5.0 → 0.6.1

package/dist/server/rpc/handlers/load-model/download-manager.js

@@ -3,43 +3,53 @@ import { getServerLogger } from "../../../../logging/index.js";
 const logger = getServerLogger();
 const activeDownloads = new Map();
 const clearCacheFlags = new Map();
-export const getActiveDownload = (key) => activeDownloads.get(key);
-export const registerDownload = (key, entry) => {
+export function getActiveDownload(key) {
+    return activeDownloads.get(key);
+}
+export function registerDownload(key, entry) {
     activeDownloads.set(key, entry);
-};
-export const unregisterDownload = (key) => {
+}
+export function unregisterDownload(key) {
     activeDownloads.delete(key);
-};
-export const createHyperdriveDownloadKey = (hyperdriveKey, modelFileName) => `${hyperdriveKey}:${modelFileName}`;
-export const createHttpDownloadKey = (url) => `http:${url}`;
-export const setClearCacheFlag = (downloadKey, clearCache) => {
+}
+export function createHyperdriveDownloadKey(hyperdriveKey, modelFileName) {
+    return `${hyperdriveKey}:${modelFileName}`;
+}
+export function createHttpDownloadKey(url) {
+    return `http:${url}`;
+}
+export function setClearCacheFlag(downloadKey, clearCache) {
     if (clearCache) {
         clearCacheFlags.set(downloadKey, true);
     }
     else {
         clearCacheFlags.delete(downloadKey);
     }
-};
-export const shouldClearCache = (downloadKey) => clearCacheFlags.get(downloadKey) ?? false;
-export const clearClearCacheFlag = (downloadKey) => {
+}
+export function shouldClearCache(downloadKey) {
+    return clearCacheFlags.get(downloadKey) ?? false;
+}
+export function clearClearCacheFlag(downloadKey) {
     clearCacheFlags.delete(downloadKey);
-};
-export const createCancelFunction = (downloadKey, clearCache = false) => () => {
-    const entry = getActiveDownload(downloadKey);
-    if (!entry) {
-        return;
-    }
-    // Set flag for the download handlers to check
-    setClearCacheFlag(downloadKey, clearCache);
-    entry.abortController.abort();
-    unregisterDownload(downloadKey);
-};
-export const cancelAllDownloads = () => {
+}
+export function createCancelFunction(downloadKey, clearCache = false) {
+    return () => {
+        const entry = getActiveDownload(downloadKey);
+        if (!entry) {
+            return;
+        }
+        // Set flag for the download handlers to check
+        setClearCacheFlag(downloadKey, clearCache);
+        entry.abortController.abort();
+        unregisterDownload(downloadKey);
+    };
+}
+export function cancelAllDownloads() {
     logger.info(`🧹 Cancelling ${activeDownloads.size} active downloads`);
     Array.from(activeDownloads.keys()).forEach((key) => createCancelFunction(key)());
-};
+}
 let isCleaningUp = false;
-export const cleanupDownloads = async () => {
+export async function cleanupDownloads() {
     if (isCleaningUp)
         return;
     isCleaningUp = true;
@@ -53,4 +63,4 @@ export const cleanupDownloads = async () => {
     catch (error) {
         logger.error("❌ Error during download cleanup:", error);
     }
-};
+}

package/dist/server/rpc/handlers/{load-model.d.ts → load-model/handler.d.ts}

@@ -1,3 +1,3 @@
-import type { LoadModelRequest, LoadModelResponse, ModelProgressUpdate } from "../../../schemas/index";
+import type { LoadModelRequest, LoadModelResponse, ModelProgressUpdate } from "../../../../schemas/index";
 export declare function handleLoadModel(request: LoadModelRequest, progressCallback?: (update: ModelProgressUpdate) => void): Promise<LoadModelResponse>;
-//# sourceMappingURL=load-model.d.ts.map
+//# sourceMappingURL=handler.d.ts.map

package/dist/server/rpc/handlers/load-model/handler.js

@@ -0,0 +1,179 @@
+import { normalizeModelType, ModelType } from "../../../../schemas/index.js";
+import { hyperdriveUrlSchema } from "../../../../schemas/load-model.js";
+import { loadModel } from "../../../bare/addons/index.js";
+import { resolveModelPath } from "./resolve.js";
+import { getModelEntry, updateModelConfig, } from "../../../bare/registry/model-registry.js";
+import { generateShortHash, transformConfigForReload } from "../../../utils/index.js";
+import { TTSConfigModelRequiredError, ESpeakDataPathRequiredError, ConfigReloadNotSupportedError, ModelTypeMismatchError, ModelIsDelegatedError, ModelNotFoundError, } from "../../../../utils/errors-server.js";
+import { getServerLogger } from "../../../../logging/index.js";
+const logger = getServerLogger();
+const OCR_DETECTOR_FILENAME = "detector_craft.onnx";
+export async function handleLoadModel(request, progressCallback) {
+    // Handle reload config
+    if (isReloadConfigRequest(request)) {
+        return handleConfigReload(request);
+    }
+    // Handle load new model from source
+    const { modelSrc, modelName, seed, projectionModelSrc, vadModelSrc, configSrc, } = request;
+    const canonicalModelType = normalizeModelType(request.modelType);
+    const srcVocabSrc = canonicalModelType === ModelType.nmtcppTranslation
+        ? request.srcVocabSrc
+        : undefined;
+    const dstVocabSrc = canonicalModelType === ModelType.nmtcppTranslation
+        ? request.dstVocabSrc
+        : undefined;
+    const eSpeakDataPath = canonicalModelType === ModelType.onnxTts
+        ? request.eSpeakDataPath
+        : undefined;
+    const detectorModelSrc = canonicalModelType === ModelType.onnxOcr
+        ? request.detectorModelSrc
+        : undefined;
+    try {
+        const modelPath = await resolveModelPath(modelSrc, progressCallback, seed);
+        let projectionModelPath;
+        if (projectionModelSrc) {
+            projectionModelPath = await resolveModelPath(projectionModelSrc, progressCallback, seed);
+        }
+        let vadModelPath;
+        if (vadModelSrc) {
+            vadModelPath = await resolveModelPath(vadModelSrc, progressCallback, seed);
+        }
+        let ttsConfigModelPath;
+        if (configSrc) {
+            ttsConfigModelPath = await resolveModelPath(configSrc, progressCallback, seed);
+        }
+        // For OCR models: use provided detectorModelSrc or auto-derive from same hyperdrive key
+        let detectorModelPath;
+        if (canonicalModelType === ModelType.onnxOcr) {
+            if (detectorModelSrc) {
+                detectorModelPath = await resolveModelPath(detectorModelSrc, progressCallback, seed);
+            }
+            else if (modelSrc.startsWith("pear://")) {
+                const { key } = hyperdriveUrlSchema.parse(modelSrc);
+                const derivedDetectorSrc = `pear://${key}/${OCR_DETECTOR_FILENAME}`;
+                detectorModelPath = await resolveModelPath(derivedDetectorSrc, progressCallback, seed);
+            }
+        }
+        // For TTS models, ttsConfigModelPath and eSpeakDataPath are required
+        if (canonicalModelType === ModelType.onnxTts && !ttsConfigModelPath) {
+            throw new TTSConfigModelRequiredError();
+        }
+        if (canonicalModelType === ModelType.onnxTts && !eSpeakDataPath) {
+            throw new ESpeakDataPathRequiredError();
+        }
+        // For Bergamot models, resolve vocabulary sources to local paths
+        if (canonicalModelType === ModelType.nmtcppTranslation &&
+            request.modelConfig) {
+            const nmtConfig = request.modelConfig;
+            if (nmtConfig.engine === "Bergamot") {
+                let resolvedSrcVocabSrc = srcVocabSrc;
+                let resolvedDstVocabSrc = dstVocabSrc;
+                if ((!srcVocabSrc || !dstVocabSrc) && modelSrc.startsWith("pear://")) {
+                    const derivedVocabSrcs = deriveBergamotVocabSources(modelSrc);
+                    if (derivedVocabSrcs) {
+                        resolvedSrcVocabSrc = srcVocabSrc ?? derivedVocabSrcs.srcVocabSrc;
+                        resolvedDstVocabSrc = dstVocabSrc ?? derivedVocabSrcs.dstVocabSrc;
+                    }
+                }
+                if (resolvedSrcVocabSrc) {
+                    nmtConfig.srcVocabPath = await resolveModelPath(resolvedSrcVocabSrc, progressCallback, seed);
+                }
+                if (resolvedDstVocabSrc) {
+                    nmtConfig.dstVocabPath = await resolveModelPath(resolvedDstVocabSrc, progressCallback, seed);
+                }
+            }
+        }
+        // Generate hash-based modelId
+        const configStr = JSON.stringify(request.modelConfig, Object.keys(request.modelConfig).sort());
+        const modelHashInput = `${request.modelType}:${modelSrc}:${configStr}`;
+        const modelId = generateShortHash(modelHashInput);
+        await loadModel({
+            modelId,
+            modelPath,
+            options: request,
+            projectionModelPath,
+            vadModelPath,
+            ttsConfigModelPath,
+            eSpeakDataPath,
+            detectorModelPath,
+            modelName,
+        });
+        return {
+            type: "loadModel",
+            success: true,
+            modelId,
+        };
+    }
+    catch (error) {
+        logger.error("Error loading model:", error);
+        return {
+            type: "loadModel",
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}
+async function handleConfigReload(request) {
+    const { modelId, modelType, modelConfig } = request;
+    try {
+        const entry = getModelEntry(modelId);
+        if (!entry) {
+            throw new ModelNotFoundError(modelId);
+        }
+        if (entry.isDelegated) {
+            throw new ModelIsDelegatedError(modelId);
+        }
+        const storedModelType = entry.local.modelType;
+        const normalizedRequestType = normalizeModelType(modelType);
+        if (storedModelType !== normalizedRequestType) {
+            throw new ModelTypeMismatchError(storedModelType, normalizedRequestType);
+        }
+        const model = entry.local.model;
+        const currentConfig = entry.local.config;
+        if (typeof model.reload !== "function") {
+            throw new ConfigReloadNotSupportedError(modelId);
+        }
+        const mergedConfig = {
+            ...currentConfig,
+            ...modelConfig,
+        };
+        const reloadConfig = transformConfigForReload(storedModelType, mergedConfig);
+        await model.reload(reloadConfig);
+        updateModelConfig(modelId, mergedConfig);
+        return {
+            type: "loadModel",
+            success: true,
+            modelId,
+        };
+    }
+    catch (error) {
+        logger.error("Error reloading config:", error);
+        return {
+            type: "loadModel",
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}
+function isReloadConfigRequest(request) {
+    return "modelId" in request && !("modelSrc" in request);
+}
+const BERGAMOT_CJK_LANG_PAIRS = ["enja", "enko", "enzh"];
+function deriveBergamotVocabSources(modelSrc) {
+    const match = modelSrc.match(/^pear:\/\/([a-f0-9]+)\/model\.([a-z]+)\.intgemm\.alphas\.bin$/);
+    if (!match || !match[1] || !match[2])
+        return null;
+    const key = match[1];
+    const langPair = match[2];
+    if (BERGAMOT_CJK_LANG_PAIRS.includes(langPair)) {
+        return {
+            srcVocabSrc: `pear://${key}/srcvocab.${langPair}.spm`,
+            dstVocabSrc: `pear://${key}/trgvocab.${langPair}.spm`,
+        };
+    }
+    const sharedVocab = `pear://${key}/vocab.${langPair}.spm`;
+    return {
+        srcVocabSrc: sharedVocab,
+        dstVocabSrc: sharedVocab,
+    };
+}