@qvac/sdk 0.1.1 → 0.2.0

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

@@ -12,7 +12,6 @@ export const unregisterDownload = (key) => {
 };
 export const createHyperdriveDownloadKey = (hyperdriveKey, modelFileName) => `${hyperdriveKey}:${modelFileName}`;
 export const createHttpDownloadKey = (url) => `http:${url}`;
-export const getAllActiveDownloads = () => new Map(activeDownloads);
 export const setClearCacheFlag = (downloadKey, clearCache) => {
     if (clearCache) {
         clearCacheFlags.set(downloadKey, true);
@@ -39,24 +38,6 @@ export const cancelAllDownloads = () => {
     console.log(`🧹 Cancelling ${activeDownloads.size} active downloads`);
     Array.from(activeDownloads.keys()).forEach((key) => createCancelFunction(key)());
 };
-export const getDownloadStats = () => ({
-    activeCount: activeDownloads.size,
-    downloads: Array.from(activeDownloads.entries()).map(([key, entry]) => ({
-        key,
-        startTime: entry.startTime,
-        duration: Date.now() - entry.startTime,
-        type: entry.type,
-        ...(entry.type === "hyperdrive"
-            ? {
-                hyperdriveKey: entry.hyperdriveKey,
-                modelFileName: entry.modelFileName,
-            }
-            : {
-                url: entry.url,
-                modelPath: entry.modelPath,
-            }),
-    })),
-});
 // Register cleanup handlers for graceful shutdown
 let cleanupRegistered = false;
 let isCleaningUp = false;
@@ -79,10 +60,14 @@ const registerCleanupHandlers = () => {
             console.error("❌ Error during download cleanup:", error);
         }
     };
-    process.on("SIGTERM", () => {
-        void cleanup();
-    });
-    process.on("SIGINT", () => {
-        void cleanup();
-    });
+    let handlingExit = false;
+    const exitHandler = async () => {
+        if (handlingExit)
+            return;
+        handlingExit = true;
+        await cleanup();
+        process.exit(0);
+    };
+    process.once("SIGTERM", () => void exitHandler());
+    process.once("SIGINT", () => void exitHandler());
 };

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

@@ -10,24 +10,49 @@ import { getEnv } from "../../../worker.js";
 import { getModelsCacheDir, generateShortHash } from "../../../utils/index.js";
 import { getModelBySrc } from "../../../../models/hyperdrive/index.js";
 import { getActiveDownload, registerDownload, unregisterDownload, createHyperdriveDownloadKey, shouldClearCache, clearClearCacheFlag, } from "./download-manager.js";
+function createProgressHandler(blob, progressCallback, downloadKey, initialBytes = 0) {
+    let downloadedBytes = initialBytes;
+    return (index, bytes) => {
+        if (index >= blob.blockOffset &&
+            index < blob.blockOffset + blob.blockLength) {
+            downloadedBytes += bytes;
+            if (progressCallback && downloadKey) {
+                progressCallback({
+                    type: "modelProgress",
+                    downloaded: downloadedBytes,
+                    total: blob.byteLength,
+                    percentage: blob.byteLength > 0 ? (downloadedBytes / blob.byteLength) * 100 : 0,
+                    downloadKey,
+                });
+            }
+        }
+    };
+}
 async function setupHyperdrive(hyperdriveKey, corestoreDir) {
     const corestore = new Corestore(corestoreDir);
     await corestore.ready();
     const drive = new Hyperdrive(corestore, Buffer.from(hyperdriveKey, "hex"));
     await drive.ready();
     const swarm = new Hyperswarm();
-    swarm.join(drive.discoveryKey, { server: false, client: true });
+    const doneFindingPeers = drive.findingPeers();
     swarm.on("connection", (connection) => {
         console.log(`🤝 Connected to peer for hyperdrive download`);
         drive.replicate(connection);
     });
-    const doneFindingPeers = drive.findingPeers();
-    await swarm.flush();
-    doneFindingPeers();
+    swarm.join(drive.discoveryKey, { server: false, client: true });
+    swarm.flush().then(doneFindingPeers, doneFindingPeers);
     return { corestore, drive, swarm, corestoreDir };
 }
 async function cleanupHyperdrive(setup) {
     console.log("🧹 Cleaning up hyperdrive setup");
+    if (!setup.swarm.suspended) {
+        try {
+            await setup.swarm.suspend();
+        }
+        catch {
+            // If suspend fails, continue with cleanup
+        }
+    }
     await setup.swarm.destroy();
     await setup.drive.close();
     await setup.corestore.close();
@@ -42,43 +67,81 @@ export async function deleteCorestoreDirectory(corestoreDir) {
     }
 }
 async function findFileInHyperdrive(drive, modelFileName) {
+    if (drive.core.length === 0) {
+        // this method will update the length of the core using the first peer it finds
+        // this will ensure that the hyperdrive is usable
+        await drive.core.update();
+    }
     const paths = [modelFileName, `/${modelFileName}`, `./${modelFileName}`];
-    let entry = null;
-    let targetPath = modelFileName;
     for (const pathVariation of paths) {
         try {
-            entry = await drive.entry(pathVariation);
+            const entry = await drive.entry(pathVariation, { wait: true });
             if (entry) {
-                targetPath = pathVariation;
-                break;
+                return { entry, targetPath: pathVariation };
             }
         }
         catch {
             // Continue trying other paths
         }
     }
-    if (!entry) {
-        // Try listing available files to help debug
-        try {
-            const rootFiles = drive.list("/", false);
-            const availableFiles = [];
-            for await (const file of rootFiles) {
+    // If not found, list available files for debugging
+    const availableFiles = [];
+    try {
+        // Try both with and without leading slash
+        for (const prefix of ["/", ""]) {
+            const files = drive.list(prefix, { recursive: true, wait: true });
+            for await (const file of files) {
                 availableFiles.push(file.key);
             }
-            if (availableFiles.length === 0) {
-                // Try without leading slash
-                const noSlashFiles = drive.list("", false);
-                for await (const file of noSlashFiles) {
-                    availableFiles.push(file.key);
-                }
-            }
-            throw new Error(`File ${modelFileName} not found in hyperdrive. Available files: ${availableFiles.join(", ")}`);
+            if (availableFiles.length > 0)
+                break;
         }
-        catch (listError) {
-            throw new Error(`File ${modelFileName} not found in hyperdrive. Could not list available files: ${listError instanceof Error ? listError.message : String(listError)}`);
+    }
+    catch {
+        // Ignore listing errors
+    }
+    const filesInfo = availableFiles.length > 0
+        ? `Available files: ${availableFiles.join(", ")}`
+        : "Could not list available files";
+    throw new Error(`File ${modelFileName} not found in hyperdrive. ${filesInfo}`);
+}
+async function checkFileDownloaded(drive, entry) {
+    const blobs = await drive.getBlobs();
+    const blob = entry?.value?.blob;
+    if (!blob) {
+        return {
+            blobs,
+            blocksDownloaded: 0,
+            totalBlocks: 0,
+            totalBytes: 0,
+        };
+    }
+    // Check how many blocks are already downloaded
+    let blocksDownloaded = 0;
+    for (let i = blob.blockOffset; i < blob.blockOffset + blob.blockLength; i++) {
+        const hasBlock = await blobs.core.has(i);
+        if (hasBlock) {
+            blocksDownloaded++;
         }
     }
-    return { entry, targetPath };
+    return {
+        blobs,
+        blocksDownloaded,
+        totalBlocks: blob.blockLength,
+        totalBytes: blob.byteLength,
+    };
+}
+async function validateFileExistence(drive, file) {
+    const { entry, targetPath } = await findFileInHyperdrive(drive, file);
+    const { blobs, blocksDownloaded, totalBlocks, totalBytes } = await checkFileDownloaded(drive, entry);
+    return {
+        entry,
+        blobs,
+        targetPath,
+        blocksDownloaded,
+        totalBlocks,
+        totalBytes,
+    };
 }
 async function validateFileChecksum(filePath, expectedChecksum) {
     console.log(`🔍 Validating SHA256 checksum...`);
@@ -153,13 +216,15 @@ async function performHyperdriveDownload(modelPath, modelFileName, hyperdriveKey
     }
     console.log(`Downloading model from hyperdrive ${hyperdriveKey} to ${modelPath}`);
     const setup = await setupHyperdrive(hyperdriveKey, corestoreDir);
-    let downloadedBytes = 0;
-    let totalBytes = 0;
     // Set up abort handler
     let readStream;
     let writeStream;
     const cleanup = () => {
         console.log("🛑 Aborting hyperdrive download...");
+        setup.swarm.suspended = true;
+        setup.swarm.suspend().catch(() => {
+            // Ignore errors during emergency suspend
+        });
         // Destroy streams if they exist
         if (readStream) {
             readStream.destroy();
@@ -169,48 +234,19 @@ async function performHyperdriveDownload(modelPath, modelFileName, hyperdriveKey
         }
     };
     signal?.addEventListener("abort", cleanup);
+    let downloadHandler;
     try {
-        const result = await findFileInHyperdrive(setup.drive, modelFileName);
-        const { entry, targetPath } = result;
-        totalBytes = entry?.value?.blob?.byteLength || 0;
-        console.log(`📏 Model size: ${totalBytes} bytes (${(totalBytes / 1024 / 1024).toFixed(2)} MB)`);
-        // Get blobs and file blob range
-        const blobs = await setup.drive.getBlobs();
+        const { entry, blobs, targetPath, blocksDownloaded, totalBlocks, totalBytes, } = await validateFileExistence(setup.drive, modelFileName);
         const blob = entry?.value?.blob;
         if (!blob) {
             throw new Error(`No blob found for ${modelFileName}`);
         }
-        // Check what blocks are already downloaded in corestore for this specific file
-        let alreadyDownloaded = 0;
-        for (let i = blob.blockOffset; i < blob.blockOffset + blob.blockLength; i++) {
-            const hasBlock = await blobs.core.has(i);
-            if (hasBlock) {
-                alreadyDownloaded++;
-            }
-        }
-        downloadedBytes = 0;
-        if (alreadyDownloaded > 0) {
-            console.log(`📥 Resuming download (${alreadyDownloaded}/${blob.blockLength} blocks already in corestore)`);
-        }
-        else {
-            console.log(`📥 Starting fresh download`);
-        }
+        // Calculate already downloaded bytes for resuming
+        const bytesPerBlock = totalBlocks > 0 ? totalBytes / totalBlocks : 0;
+        const initialBytes = Math.floor(blocksDownloaded * bytesPerBlock);
         // Track only downloads for blocks within our file's blob range
-        blobs.core.on("download", (index, bytes) => {
-            if (index >= blob.blockOffset &&
-                index < blob.blockOffset + blob.blockLength) {
-                downloadedBytes += bytes;
-                if (progressCallback) {
-                    progressCallback({
-                        type: "modelProgress",
-                        downloaded: downloadedBytes,
-                        total: totalBytes,
-                        percentage: totalBytes > 0 ? (downloadedBytes / totalBytes) * 100 : 0,
-                        downloadKey,
-                    });
-                }
-            }
-        });
+        downloadHandler = createProgressHandler(blob, progressCallback, downloadKey, initialBytes);
+        blobs.core.on("download", downloadHandler);
         // Check if aborted before starting streams
         if (signal?.aborted) {
             throw new Error("Download cancelled");
@@ -223,15 +259,13 @@ async function performHyperdriveDownload(modelPath, modelFileName, hyperdriveKey
         readStream.pipe(writeStream);
         // Wait for download to complete
         await new Promise((resolve, reject) => {
-            writeStream.on("finish", () => resolve(undefined));
+            writeStream.on("finish", resolve);
             writeStream.on("error", reject);
             readStream.on("error", reject);
             // Also reject on abort
-            if (signal) {
-                signal.addEventListener("abort", () => {
-                    reject(new Error("Download cancelled"));
-                }, { once: true });
-            }
+            signal?.addEventListener("abort", () => {
+                reject(new Error("Download cancelled"));
+            }, { once: true });
         });
         console.log(`✅ Model downloaded successfully to ${modelPath}`);
         // Delete corestore directory after successful download (only when not seeding, to save space)
@@ -249,22 +283,29 @@ async function performHyperdriveDownload(modelPath, modelFileName, hyperdriveKey
     }
     finally {
         signal?.removeEventListener("abort", cleanup);
+        if (downloadHandler) {
+            try {
+                const { blobs } = await validateFileExistence(setup.drive, modelFileName);
+                blobs.core.off("download", downloadHandler);
+            }
+            catch {
+                // If we can't get blobs, setup is already closed
+            }
+        }
         if (!seed) {
             await cleanupHyperdrive(setup);
         }
         // Only delete corestore and partial file if user explicitly requested clearCache
-        if (signal?.aborted) {
-            if (shouldClearCache(downloadKey)) {
-                try {
-                    await fsPromises.unlink(modelPath);
-                }
-                catch {
-                    // no-op
-                }
-                await deleteCorestoreDirectory(corestoreDir);
+        if (signal?.aborted && shouldClearCache(downloadKey)) {
+            try {
+                await fsPromises.unlink(modelPath);
+            }
+            catch {
+                // no-op
             }
-            clearClearCacheFlag(downloadKey);
+            await deleteCorestoreDirectory(corestoreDir);
         }
+        clearClearCacheFlag(downloadKey);
     }
 }
 export async function downloadModelFromHyperdrive(hyperdriveKey, modelFileName, seed, progressCallback, expectedChecksum) {

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

@@ -1,46 +1,10 @@
-import { getModelBySrc, models } from "../../../../models/hyperdrive/models.js";
+import { models } from "../../../../models/hyperdrive/models.js";
 import { hyperdriveUrlSchema } from "../../../../schemas/index.js";
 import { getModelsCacheDir } from "../../../utils/index.js";
 import { promises as fsPromises } from "bare-fs";
 import path from "bare-path";
 import { downloadModelFromHttp } from "./http.js";
 import { downloadModelFromHyperdrive } from "./hyperdrive.js";
-/**
- * Attempts to resolve a model from cache (without validation)
- * Validation will be handled by the hyperdrive download logic
- */
-async function tryResolveCachedModel(modelId) {
-    const cacheDir = getModelsCacheDir();
-    const cachedPath = path.join(cacheDir, modelId);
-    try {
-        await fsPromises.access(cachedPath);
-        // File exists - return null to let hyperdrive validation handle size/checksum
-        // This ensures partial downloads are properly resumed instead of being
-        // incorrectly validated and deleted
-        return null;
-    }
-    catch {
-        // File doesn't exist
-        return null;
-    }
-}
-/**
- * Resolves a known model by ID from hyperdrive, checking cache first
- */
-async function resolveKnownModel(model, modelIdOrPath, progressCallback, seed) {
-    if (!model) {
-        throw new Error("Model is null");
-    }
-    console.log(`Loading model ID '${modelIdOrPath}' from hyperdrive`);
-    // Try to resolve from cache first
-    const cachedPath = await tryResolveCachedModel(model.modelId);
-    if (cachedPath) {
-        return cachedPath;
-    }
-    // Not cached or invalid, download from hyperdrive
-    const downloadedPath = await downloadModelFromHyperdrive(model.hyperdriveKey, model.modelId, seed, progressCallback, model.sha256Checksum);
-    return downloadedPath;
-}
 /**
  * Resolves a local file path or cached file
  */
@@ -84,10 +48,7 @@ export async function resolveModelPath(modelSrc, progressCallback, seed) {
     let actualPath;
     // Validate seeding is only used with hyperdrive models
     if (seed && !hyperdriveKey) {
-        const model = getModelBySrc(actualModelSrc);
-        if (!model) {
-            throw new Error("Seeding is only supported for hyperdrive models");
-        }
+        throw new Error("Seeding is only supported for hyperdrive models");
     }
     // Check if it's an HTTP/HTTPS URL
     if (actualModelSrc.startsWith("http://") ||
@@ -101,21 +62,13 @@ export async function resolveModelPath(modelSrc, progressCallback, seed) {
         console.log(`Loading from hyperdrive: ${hyperdriveKey}`);
         actualPath = await downloadModelFromHyperdrive(hyperdriveKey, actualModelSrc, seed, progressCallback);
     }
+    else if (actualModelSrc.includes("/") || actualModelSrc.includes("\\")) {
+        // Handle file paths (absolute or relative with slashes)
+        actualPath = actualModelSrc;
+    }
     else {
-        // Try to resolve as a known model ID
-        const model = getModelBySrc(actualModelSrc);
-        if (model) {
-            actualPath = await resolveKnownModel(model, actualModelSrc, progressCallback, seed);
-        }
-        else if (actualModelSrc.includes("/") || actualModelSrc.includes("\\")) {
-            // Handle file paths (absolute or relative with slashes)
-            console.log(`Loading from file: ${actualModelSrc}`);
-            actualPath = actualModelSrc;
-        }
-        else {
-            // Handle local files and cached files
-            actualPath = await resolveLocalOrCachedFile(actualModelSrc);
-        }
+        // Handle local files and cached files
+        actualPath = await resolveLocalOrCachedFile(actualModelSrc);
     }
     return actualPath;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qvac/sdk",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -45,7 +45,7 @@
     "bare:ensureprebuilds:whispercpp": "cp -r node_modules/@qvac/transcription-whispercpp/prebuilds/android-arm64 node_modules/@qvac/transcription-whispercpp/prebuilds/android-ia32 && cp -r node_modules/@qvac/transcription-whispercpp/prebuilds/android-arm64 node_modules/@qvac/transcription-whispercpp/prebuilds/android-arm && cp -r node_modules/@qvac/transcription-whispercpp/prebuilds/android-arm64 node_modules/@qvac/transcription-whispercpp/prebuilds/android-x64",
     "bare:ensureprebuilds:embeddings": "cp -r node_modules/@qvac/embed-llamacpp/prebuilds/android-arm64 node_modules/@qvac/embed-llamacpp/prebuilds/android-ia32 && cp -r node_modules/@qvac/embed-llamacpp/prebuilds/android-arm64 node_modules/@qvac/embed-llamacpp/prebuilds/android-arm && cp -r node_modules/@qvac/embed-llamacpp/prebuilds/android-arm64 node_modules/@qvac/embed-llamacpp/prebuilds/android-x64",
     "bare:ensureprebuilds": "bun run bare:ensureprebuilds:llamacpp && bun run bare:ensureprebuilds:whispercpp && bun run bare:ensureprebuilds:embeddings",
-    "prepare": "bun run husky",
+    "prepare:husky": "bun run husky",
     "bare:example": "./scripts/run-with-bare.sh",
     "docs_api:website": "typedoc --out ./docs/api/website --entryPoints index.ts --entryPointStrategy expand --readme none",
     "docs_api:markdown": "typedoc --plugin typedoc-plugin-markdown --out ./docs/api/markdown --entryPoints index.ts --entryPointStrategy expand --readme none && sed -i '1,4d' ./docs/api/markdown/README.md",
@@ -53,13 +53,13 @@
     "update-models": "node ./scripts/update-models.js"
   },
   "dependencies": {
-    "@qvac/embed-llamacpp": "^0.1.0",
-    "@qvac/llm-llamacpp": "^0.2.2",
+    "@qvac/embed-llamacpp": "^0.3.1",
+    "@qvac/llm-llamacpp": "^0.3.2",
     "@qvac/decoder-audio": "^0.1.0",
     "@qvac/error": "^0.1.0",
     "@qvac/langdetect-text": "^0.1.0",
     "@qvac/logging": "^0.1.0",
-    "@qvac/rag": "^0.1.0",
+    "@qvac/rag": "^0.2.1",
     "@qvac/transcription-whispercpp": "^0.1.4",
     "@qvac/translation-nmtcpp": "^0.1.0",
     "fast-safe-stringify": "2.1.1",
@@ -126,4 +126,4 @@
   "patchedDependencies": {
     "bare-rpc@0.2.11": "patches/bare-rpc@0.2.11.patch"
   }
-}
+}