@qvac/sdk 0.2.3-dev.1760899404.f30d071 → 0.2.3-dev.1760967206.fa44856

package/dist/examples/rag/rag-hyperdb-workspaces.js

@@ -41,9 +41,10 @@ try {
         documents: medicalArticle,
         chunk: true,
         chunkOpts: {
-            chunkSize: 30,
+            chunkSize: 100,
             chunkOverlap: 10,
             chunkStrategy: "paragraph",
+            splitStrategy: "token",
         },
     });
     console.log(`✅ Created ${medicalResult.processed.length} chunks from medical article`);

package/dist/schemas/common.d.ts

@@ -486,6 +486,7 @@ export declare const requestSchema: z.ZodUnion<readonly [z.ZodObject<{
             paragraph: "paragraph";
         }>>;
         splitStrategy: z.ZodOptional<z.ZodEnum<{
+            token: "token";
             character: "character";
             word: "word";
             sentence: "sentence";

package/dist/schemas/rag.d.ts

@@ -25,6 +25,7 @@ declare const ragSaveEmbeddingsParamsSchema: z.ZodObject<{
             paragraph: "paragraph";
         }>>;
         splitStrategy: z.ZodOptional<z.ZodEnum<{
+            token: "token";
             character: "character";
             word: "word";
             sentence: "sentence";
@@ -45,6 +46,7 @@ export declare const ragSaveEmbeddingsOperationSchema: z.ZodObject<{
             paragraph: "paragraph";
         }>>;
         splitStrategy: z.ZodOptional<z.ZodEnum<{
+            token: "token";
             character: "character";
             word: "word";
             sentence: "sentence";
@@ -95,6 +97,7 @@ export declare const ragRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             paragraph: "paragraph";
         }>>;
         splitStrategy: z.ZodOptional<z.ZodEnum<{
+            token: "token";
             character: "character";
             word: "word";
             sentence: "sentence";

package/dist/schemas/rag.js

@@ -4,7 +4,9 @@ const llmChunkOptsSchema = z.object({
     chunkSize: z.number().optional(),
     chunkOverlap: z.number().optional(),
     chunkStrategy: z.enum(["character", "paragraph"]).optional(),
-    splitStrategy: z.enum(["character", "word", "sentence", "line"]).optional(),
+    splitStrategy: z
+        .enum(["character", "word", "token", "sentence", "line"])
+        .optional(),
 });
 const ragSaveEmbeddingsResultSchema = z.object({
     status: z.enum(["fulfilled", "rejected"]),

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

@@ -4,28 +4,9 @@ export declare const registerDownload: (key: string, entry: DownloadEntry) => vo
 export declare const unregisterDownload: (key: string) => void;
 export declare const createHyperdriveDownloadKey: (hyperdriveKey: string, modelFileName: string) => string;
 export declare const createHttpDownloadKey: (url: string) => string;
-export declare const getAllActiveDownloads: () => Map<string, DownloadEntry>;
 export declare const setClearCacheFlag: (downloadKey: string, clearCache: boolean) => void;
 export declare const shouldClearCache: (downloadKey: string) => boolean;
 export declare const clearClearCacheFlag: (downloadKey: string) => void;
 export declare const createCancelFunction: (downloadKey: string, clearCache?: boolean) => () => void;
 export declare const cancelAllDownloads: () => void;
-export declare const getDownloadStats: () => {
-    activeCount: number;
-    downloads: ({
-        hyperdriveKey: string;
-        modelFileName: string;
-        key: string;
-        startTime: number;
-        duration: number;
-        type: "hyperdrive" | "http";
-    } | {
-        url: string;
-        modelPath: string;
-        key: string;
-        startTime: number;
-        duration: number;
-        type: "hyperdrive" | "http";
-    })[];
-};
 //# sourceMappingURL=download-manager.d.ts.map

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,6 +10,24 @@ 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();
@@ -28,6 +46,14 @@ async function setupHyperdrive(hyperdriveKey, 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();
@@ -43,42 +69,75 @@ export async function deleteCorestoreDirectory(corestoreDir) {
 }
 async function findFileInHyperdrive(drive, modelFileName) {
     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);
             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, false);
+            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 +212,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 +230,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 +255,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 +279,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qvac/sdk",
-  "version": "0.2.3-dev.1760899404.f30d071",
+  "version": "0.2.3-dev.1760967206.fa44856",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -59,7 +59,7 @@
     "@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.0",
     "@qvac/transcription-whispercpp": "^0.1.4",
     "@qvac/translation-nmtcpp": "^0.1.0",
     "fast-safe-stringify": "2.1.1",