@qvac/sdk 0.4.1 → 0.6.0

package/dist/server/rpc/handlers/rag.js

@@ -1,9 +1,43 @@
-import { saveEmbeddings, search, deleteEmbeddings, } from "../../bare/rag-hyperdb/index.js";
-export async function handleRag(request) {
-    try {
-        switch (request.operation) {
-            case "saveEmbeddings": {
-                const result = await saveEmbeddings(request);
+import { chunk, ingest, reindex, saveEmbeddings, search, deleteEmbeddings, listWorkspaces, closeWorkspace, deleteWorkspace, DEFAULT_WORKSPACE, registerRagOperation, unregisterRagOperation, } from "../../bare/rag-hyperdb/index.js";
+function createHandlerOptions(operation, workspace, onProgress) {
+    const signal = registerRagOperation(workspace, operation);
+    const options = { signal };
+    if (onProgress) {
+        options.onProgress = (stage, current, total) => onProgress({
+            type: "rag:progress",
+            operation,
+            workspace,
+            stage,
+            current,
+            total,
+            timestamp: Date.now(),
+        });
+    }
+    return options;
+}
+function omitOnProgress(obj) {
+    const { onProgress, withProgress, ...rest } = obj;
+    void onProgress;
+    void withProgress;
+    return rest;
+}
+export async function handleRag(request, onProgress) {
+    switch (request.operation) {
+        case "chunk": {
+            const chunks = await chunk(request);
+            return {
+                type: "rag",
+                operation: request.operation,
+                success: true,
+                chunks,
+            };
+        }
+        case "ingest": {
+            const workspace = request.workspace ?? DEFAULT_WORKSPACE;
+            const handlerOptions = createHandlerOptions("ingest", workspace, onProgress);
+            const params = omitOnProgress(request);
+            try {
+                const result = await ingest(params, handlerOptions);
                 return {
                     type: "rag",
                     operation: request.operation,
@@ -12,53 +46,85 @@ export async function handleRag(request) {
                     droppedIndices: result.droppedIndices,
                 };
             }
-            case "search": {
-                const results = await search(request);
+            finally {
+                unregisterRagOperation(workspace);
+            }
+        }
+        case "saveEmbeddings": {
+            const workspace = request.workspace ?? DEFAULT_WORKSPACE;
+            const handlerOptions = createHandlerOptions("saveEmbeddings", workspace, onProgress);
+            const params = omitOnProgress(request);
+            try {
+                const processed = await saveEmbeddings(params, handlerOptions);
                 return {
                     type: "rag",
                     operation: request.operation,
                     success: true,
-                    results,
+                    processed,
                 };
             }
-            case "deleteEmbeddings": {
-                const success = await deleteEmbeddings(request);
+            finally {
+                unregisterRagOperation(workspace);
+            }
+        }
+        case "search": {
+            const results = await search(request);
+            return {
+                type: "rag",
+                operation: request.operation,
+                success: true,
+                results,
+            };
+        }
+        case "deleteEmbeddings": {
+            await deleteEmbeddings(request);
+            return {
+                type: "rag",
+                operation: request.operation,
+                success: true,
+            };
+        }
+        case "reindex": {
+            const workspace = request.workspace ?? DEFAULT_WORKSPACE;
+            const handlerOptions = createHandlerOptions("reindex", workspace, onProgress);
+            const params = omitOnProgress(request);
+            try {
+                const result = await reindex(params, handlerOptions);
                 return {
                     type: "rag",
                     operation: request.operation,
-                    success,
+                    success: true,
+                    result,
                 };
             }
+            finally {
+                unregisterRagOperation(workspace);
+            }
         }
-    }
-    catch (error) {
-        console.error("Error in RAG handler:", error);
-        const baseError = {
-            type: "rag",
-            success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
-        };
-        switch (request.operation) {
-            case "saveEmbeddings":
-                return {
-                    ...baseError,
-                    operation: request.operation,
-                    processed: [],
-                    droppedIndices: [],
-                };
-            case "search":
-                return {
-                    ...baseError,
-                    operation: request.operation,
-                    results: [],
-                };
-            case "deleteEmbeddings":
-                return {
-                    ...baseError,
-                    operation: request.operation,
-                };
-            default:
-                throw error;
+        case "listWorkspaces": {
+            const workspaces = listWorkspaces();
+            return {
+                type: "rag",
+                operation: request.operation,
+                success: true,
+                workspaces,
+            };
+        }
+        case "closeWorkspace": {
+            await closeWorkspace(request);
+            return {
+                type: "rag",
+                operation: request.operation,
+                success: true,
+            };
+        }
+        case "deleteWorkspace": {
+            await deleteWorkspace(request);
+            return {
+                type: "rag",
+                operation: request.operation,
+                success: true,
+            };
         }
     }
 }

package/dist/server/rpc/handlers/stopProvideHandler.js

@@ -1,4 +1,6 @@
 import { getSwarm, unregisterProviderTopic } from "../../bare/hyperswarm.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 export function stopProvideHandler(request) {
     const swarm = getSwarm();
     try {
@@ -12,7 +14,7 @@ export function stopProvideHandler(request) {
         };
     }
     catch (error) {
-        console.error("❌ Error in stop provide handler:", error);
+        logger.error("❌ Error in stop provide handler:", error);
         return {
             type: "stopProvide",
             success: false,

package/dist/server/rpc/handlers/text-to-speech.js

@@ -1,4 +1,4 @@
-import { textToSpeech } from "../../bare/addons/tts/index.js";
+import { textToSpeech } from "../../bare/addons/onnx-tts/index.js";
 export async function* handleTextToSpeech(request) {
     const stream = textToSpeech(request);
     for await (const response of stream) {

package/dist/server/rpc/handlers/transcribe-stream.js

@@ -1,4 +1,6 @@
-import { transcribeStream } from "../../bare/addons/whispercpp/index.js";
+import { transcribeStream } from "../../bare/addons/whispercpp-transcription/index.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 export async function* handleTranscribeStream(request) {
     const { modelId, audioChunk, prompt } = request;
     try {
@@ -20,7 +22,7 @@ export async function* handleTranscribeStream(request) {
         };
     }
     catch (error) {
-        console.error("Error during transcription:", error);
+        logger.error("Error during transcription:", error);
         yield {
             type: "transcribeStream",
             text: "",

package/dist/server/rpc/handlers/translate.js

@@ -1,19 +1,12 @@
-import { translate } from "../../bare/addons/translation/index.js";
+import { translate } from "../../bare/addons/nmtcpp-translation/index.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 export async function* handleTranslate(request) {
-    const { modelId, text, stream, modelType } = request;
-    const from = request.modelType === "llm" ? request.from : undefined;
-    const to = request.modelType === "llm" ? request.to : undefined;
-    const context = request.modelType === "llm" ? request.context : undefined;
     try {
-        const generator = translate({
-            modelId,
-            text,
-            from,
-            to: to,
-            stream,
-            modelType,
-            context,
-        });
+        // Remove the 'type' field from request and pass the rest to translate
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { type, ...translateParams } = request;
+        const generator = translate(translateParams);
         let stats;
         let done = false;
         let buffer = "";
@@ -25,7 +18,7 @@ export async function* handleTranslate(request) {
             }
             else {
                 buffer += result.value;
-                if (stream) {
+                if (translateParams.stream) {
                     yield {
                         type: "translate",
                         token: result.value,
@@ -41,7 +34,7 @@ export async function* handleTranslate(request) {
         };
     }
     catch (error) {
-        console.error("Error during translation:", error);
+        logger.error("Error during translation:", error);
         yield {
             type: "translate",
             token: "",

package/dist/server/rpc/handlers/unload-model.js

@@ -1,10 +1,12 @@
 import { unloadModel } from "../../bare/addons/index.js";
 import { getRegistryStats } from "../../bare/registry/model-registry.js";
 import { hasActiveProviders } from "../../bare/hyperswarm.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 export async function handleUnloadModel(request) {
     const { modelId, clearStorage } = request;
     try {
-        console.log("Unloading model", modelId);
+        logger.debug("Unloading model", modelId);
         await unloadModel({ modelId, clearStorage });
         const stats = getRegistryStats();
         const modelsActive = stats.totalModels > 0;
@@ -17,7 +19,7 @@ export async function handleUnloadModel(request) {
         };
     }
     catch (error) {
-        console.error("Error during model unload:", error);
+        logger.error("Error during model unload:", error);
         return {
             type: "unloadModel",
             success: false,

package/dist/server/utils/archive.d.ts

@@ -0,0 +1,3 @@
+export declare function isArchiveUrl(url: string): boolean;
+export declare function extractAndValidateShardedArchive(archivePath: string, extractDir: string, signal?: AbortSignal): Promise<string>;
+//# sourceMappingURL=archive.d.ts.map

package/dist/server/utils/archive.js

@@ -0,0 +1,171 @@
+import { promises as fsPromises } from "bare-fs";
+import path from "bare-path";
+import fs from "bare-fs";
+import { createGunzip } from "bare-zlib";
+import tarStream from "tar-stream";
+import { detectShardedModel, generateShardFilenames, extractTensorsFromShards, validateShardedModelCache, } from "./shard-utils.js";
+import { ModelLoadFailedError, ArchiveExtractionFailedError, ArchiveUnsupportedTypeError, ArchiveMissingShardsError, DownloadCancelledError, } from "../../utils/errors-server.js";
+import { getServerLogger } from "../../logging/index.js";
+import { SUPPORTED_ARCHIVE_EXTENSIONS, filenameToArchiveTypeSchema, } from "../../schemas/archive.js";
+const logger = getServerLogger();
+// Gzip magic bytes: 1f 8b 08
+const GZIP_MAGIC_0 = 0x1f;
+const GZIP_MAGIC_1 = 0x8b;
+const GZIP_MAGIC_2 = 0x08;
+export function isArchiveUrl(url) {
+    const filename = url.split("/").pop()?.split("?")[0]?.toLowerCase() || "";
+    return SUPPORTED_ARCHIVE_EXTENSIONS.some((ext) => filename.endsWith(ext));
+}
+// Whitelist of model file extensions to extract from archives
+const ALLOWED_MODEL_EXTENSIONS = [".gguf", ".tensors.txt"];
+function isModelFile(entryName) {
+    const basename = path.basename(entryName);
+    // Skip resource forks (._filename)
+    if (basename.startsWith("._")) {
+        return false;
+    }
+    return ALLOWED_MODEL_EXTENSIONS.some((ext) => basename.toLowerCase().endsWith(ext));
+}
+async function isGzip(archivePath) {
+    return new Promise((resolve, reject) => {
+        const stream = fs.createReadStream(archivePath, { start: 0, end: 2 });
+        const chunks = [];
+        stream.on("data", (chunk) => {
+            chunks.push(chunk);
+        });
+        stream.on("end", () => {
+            stream.destroy();
+            const buffer = Buffer.concat(chunks);
+            // Check for gzip magic bytes
+            const isGzipped = buffer[0] === GZIP_MAGIC_0 &&
+                buffer[1] === GZIP_MAGIC_1 &&
+                buffer[2] === GZIP_MAGIC_2;
+            resolve(isGzipped);
+        });
+        stream.on("error", reject);
+    });
+}
+async function extractArchive(archivePath, extractDir, signal) {
+    const parseResult = filenameToArchiveTypeSchema.safeParse(archivePath);
+    const extensionType = parseResult.success ? parseResult.data : null;
+    if (!extensionType) {
+        throw new ArchiveUnsupportedTypeError(archivePath);
+    }
+    if (signal?.aborted) {
+        throw new DownloadCancelledError();
+    }
+    // Detect actual format from magic bytes (extension might be wrong)
+    const isGzipped = await isGzip(archivePath);
+    const actualType = isGzipped ? "tar.gz" : "tar";
+    if (actualType !== extensionType) {
+        logger.warn(`⚠️ Archive extension suggests ${extensionType} but content is ${actualType}`);
+    }
+    await fsPromises.mkdir(extractDir, { recursive: true });
+    await extractTarStream(archivePath, extractDir, isGzipped, signal);
+}
+async function extractTarStream(archivePath, extractDir, useGunzip, signal) {
+    const extract = tarStream.extract();
+    const gunzip = useGunzip ? createGunzip() : null;
+    return new Promise((resolve, reject) => {
+        let aborted = false;
+        let readStream = null;
+        const cleanup = () => {
+            aborted = true;
+            readStream?.destroy();
+            gunzip?.destroy();
+            extract.destroy();
+        };
+        if (signal) {
+            signal.addEventListener("abort", () => {
+                cleanup();
+                reject(new DownloadCancelledError());
+            });
+        }
+        extract.on("entry", (header, stream, next) => {
+            if (aborted) {
+                stream.resume();
+                return;
+            }
+            if (!isModelFile(header.name)) {
+                stream.resume();
+                next();
+                return;
+            }
+            const filePath = path.join(extractDir, header.name);
+            if (header.type === "file") {
+                const dir = path.dirname(filePath);
+                fs.mkdirSync(dir, { recursive: true });
+                const writeStream = fs.createWriteStream(filePath);
+                stream.pipe(writeStream);
+                writeStream.on("finish", next);
+                writeStream.on("error", reject);
+            }
+            else {
+                stream.on("end", next);
+                stream.resume();
+            }
+        });
+        extract.on("finish", resolve);
+        extract.on("error", reject);
+        if (gunzip) {
+            gunzip.on("error", reject);
+        }
+        readStream = fs.createReadStream(archivePath);
+        if (gunzip) {
+            readStream.pipe(gunzip).pipe(extract);
+        }
+        else {
+            readStream.pipe(extract);
+        }
+    });
+}
+export async function extractAndValidateShardedArchive(archivePath, extractDir, signal) {
+    // Check if shards already extracted
+    try {
+        const existingFiles = await fsPromises.readdir(extractDir);
+        const existingShard = existingFiles.find((f) => detectShardedModel(String(f)).isSharded);
+        if (existingShard) {
+            const isComplete = await validateShardedModelCache(extractDir, String(existingShard));
+            if (isComplete) {
+                logger.info(`✅ Archive already extracted: ${extractDir}`);
+                const shardFilenames = generateShardFilenames(String(existingShard));
+                return path.join(extractDir, shardFilenames[0]);
+            }
+            logger.warn(`⚠️ Incomplete extraction found, re-extracting archive`);
+        }
+    }
+    catch {
+        // Directory doesn't exist, proceed with extraction
+    }
+    logger.info(`Extracting archive: ${path.basename(archivePath)}`);
+    try {
+        await extractArchive(archivePath, extractDir, signal);
+    }
+    catch (error) {
+        throw new ArchiveExtractionFailedError(archivePath, error);
+    }
+    const files = await fsPromises.readdir(extractDir);
+    const shardedFile = files.find((f) => detectShardedModel(String(f)).isSharded);
+    if (!shardedFile) {
+        throw new ModelLoadFailedError(`No sharded model files found in archive. Expected pattern: *-00001-of-0000X.*`);
+    }
+    const shardedFileName = String(shardedFile);
+    const shardInfo = detectShardedModel(shardedFileName);
+    if (!shardInfo.baseFilename) {
+        throw new ModelLoadFailedError(`Could not extract base filename from sharded model: ${shardedFileName}`);
+    }
+    const shardFilenames = generateShardFilenames(shardedFileName);
+    for (const shardFilename of shardFilenames) {
+        const filePath = path.join(extractDir, shardFilename);
+        try {
+            await fsPromises.access(filePath);
+        }
+        catch {
+            throw new ArchiveMissingShardsError(shardFilename);
+        }
+    }
+    // Generate tensors.txt if it doesn't exist
+    await extractTensorsFromShards(extractDir, shardedFileName);
+    logger.info(`Archive extracted to ${extractDir} successfully: ${files.length} files`);
+    return path.join(extractDir, shardFilenames[0]);
+}

package/dist/server/utils/audio/decoder.d.ts

@@ -1,4 +1,5 @@
 import { Readable } from "bare-stream";
+import { type AudioFormat } from "../../../schemas/index";
 export declare function needsDecoding(filePath: string): boolean;
-export declare function decodeAudioToStream(inputPath: string): Promise<Readable>;
+export declare function decodeAudioToStream(inputPath: string, audioFormat?: AudioFormat): Promise<Readable>;
 //# sourceMappingURL=decoder.d.ts.map

package/dist/server/utils/audio/decoder.js

@@ -1,17 +1,20 @@
 import fs from "bare-fs";
 import path from "bare-path";
-import GSTDecoder from "@qvac/decoder-audio";
+import { FFmpegDecoder } from "@qvac/decoder-audio";
 import { FORMATS_NEEDING_DECODE } from "@qvac/decoder-audio/constants.js";
 import { Readable } from "bare-stream";
+import { getServerLogger } from "../../../logging/index.js";
+import {} from "../../../schemas/index.js";
+const logger = getServerLogger();
 export function needsDecoding(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     return FORMATS_NEEDING_DECODE.includes(ext);
 }
-export async function decodeAudioToStream(inputPath) {
-    const decoder = new GSTDecoder({
-        config: {
-            audioFormat: "encoded",
-        },
+const DECODER_TIMEOUT_MS = 10000;
+export async function decodeAudioToStream(inputPath, audioFormat = "s16le") {
+    const decoder = new FFmpegDecoder({
+        config: { audioFormat },
+        logger,
     });
     try {
         await decoder.load();
@@ -20,22 +23,56 @@ export async function decodeAudioToStream(inputPath) {
         const outputStream = new Readable({
             read() { },
         });
+        let hasReceivedData = false;
+        let hasEnded = false;
+        // Fallback timeout in case the decoder hangs without emitting any events
+        const timeoutId = setTimeout(() => {
+            if (!hasEnded) {
+                hasEnded = true;
+                const timeoutError = new Error(`Audio decoding timed out after ${DECODER_TIMEOUT_MS}ms for file: ${inputPath}`);
+                outputStream.destroy(timeoutError);
+            }
+        }, DECODER_TIMEOUT_MS);
         response
             .onUpdate((output) => {
+            hasReceivedData = true;
             const bytes = new Uint8Array(output.outputArray);
             outputStream.push(Buffer.from(bytes));
         })
             .onFinish(() => {
-            outputStream.push(null);
+            if (!hasEnded) {
+                hasEnded = true;
+                clearTimeout(timeoutId);
+                setImmediate(() => void decoder.unload());
+                if (!hasReceivedData) {
+                    outputStream.destroy(new Error(`No audio data decoded from file: ${inputPath}`));
+                }
+                else {
+                    outputStream.push(null);
+                }
+            }
         })
-            .await()
-            .catch((error) => {
-            outputStream.destroy(error instanceof Error ? error : new Error(String(error)));
+            .onError((error) => {
+            if (!hasEnded) {
+                hasEnded = true;
+                clearTimeout(timeoutId);
+                setImmediate(() => void decoder.unload());
+                outputStream.destroy(error);
+            }
+        });
+        response.await().catch((error) => {
+            if (!hasEnded) {
+                hasEnded = true;
+                clearTimeout(timeoutId);
+                setImmediate(() => void decoder.unload());
+                outputStream.destroy(error instanceof Error ? error : new Error(String(error)));
+            }
         });
         return outputStream;
     }
     catch (error) {
-        console.error("Decoding failed:", error instanceof Error ? error.message : String(error));
+        await decoder.unload();
+        logger.error("Decoding failed:", error instanceof Error ? error.message : String(error));
         throw error;
     }
 }

package/dist/server/utils/cache.d.ts

@@ -1,7 +1,7 @@
-import type { ShardMetadata } from "./shard-utils";
-export declare const getCacheDir: (subDir: string) => string;
-export declare const getModelsCacheDir: () => string;
-export declare const getKVCacheDir: () => string;
+import type { ShardFileMetadata } from "../../schemas/index";
+export declare function getCacheDir(subDir: string): string;
+export declare function getModelsCacheDir(): string;
+export declare function getKVCacheDir(): string;
 /**
  * Get cache directory for sharded model
  * Returns: cache/sharded/<hyperdriveKey>/
@@ -16,5 +16,5 @@ export declare function getShardPath(hyperdriveKey: string, shardFilename: strin
  * Check if all shards exist and are valid (size + checksum check)
  * Returns array of missing/invalid shard indices (0-based)
  */
-export declare function checkShardCompleteness(hyperdriveKey: string, shardFilenames: readonly string[], shardMetadata: readonly ShardMetadata[]): Promise<number[]>;
+export declare function checkShardCompleteness(hyperdriveKey: string, shardFilenames: readonly string[], shardMetadata: readonly ShardFileMetadata[]): Promise<number[]>;
 //# sourceMappingURL=cache.d.ts.map

package/dist/server/utils/cache.js

@@ -3,30 +3,32 @@ import path from "bare-path";
 import { getEnv } from "../worker.js";
 import { getConfiguredCacheDir } from "../bare/registry/config-registry.js";
 import { calculateFileChecksum } from "./checksum.js";
-export const getCacheDir = (subDir) => {
+import { getServerLogger } from "../../logging/index.js";
+const logger = getServerLogger();
+export function getCacheDir(subDir) {
     const homeDir = getEnv().HOME_DIR;
     const cacheDir = path.join(homeDir, ".qvac", subDir);
     try {
         fs.mkdirSync(cacheDir, { recursive: true });
     }
     catch (error) {
-        console.error(`Error creating cache directory (${subDir}):`, error instanceof Error ? error.message : String(error));
+        logger.error(`Error creating cache directory (${subDir}):`, error instanceof Error ? error.message : String(error));
     }
     return cacheDir;
-};
-export const getModelsCacheDir = () => {
+}
+export function getModelsCacheDir() {
     const configuredDir = getConfiguredCacheDir();
     try {
         fs.mkdirSync(configuredDir, { recursive: true });
     }
     catch (error) {
-        console.error(`Error creating models cache directory:`, error instanceof Error ? error.message : String(error));
+        logger.error(`Error creating models cache directory:`, error instanceof Error ? error.message : String(error));
     }
     return configuredDir;
-};
-export const getKVCacheDir = () => {
+}
+export function getKVCacheDir() {
     return getCacheDir("kv-cache");
-};
+}
 /**
  * Get cache directory for sharded model
  * Returns: cache/sharded/<hyperdriveKey>/
@@ -38,7 +40,7 @@ export function getShardedModelCacheDir(hyperdriveKey) {
         fs.mkdirSync(shardDir, { recursive: true });
     }
     catch (error) {
-        console.error(`Error creating sharded model cache directory:`, error instanceof Error ? error.message : String(error));
+        logger.error(`Error creating sharded model cache directory:`, error instanceof Error ? error.message : String(error));
     }
     return shardDir;
 }
@@ -66,14 +68,14 @@ export async function checkShardCompleteness(hyperdriveKey, shardFilenames, shar
         try {
             const stats = await fsPromises.stat(shardPath);
             if (stats.size !== fileMeta.expectedSize) {
-                console.warn(`File ${i + 1} size mismatch: expected ${fileMeta.expectedSize}, got ${stats.size}`);
+                logger.warn(`File ${i + 1} size mismatch: expected ${fileMeta.expectedSize}, got ${stats.size}`);
                 invalidIndices.push(i);
                 continue;
             }
             if (fileMeta.sha256Checksum) {
                 const actualChecksum = await calculateFileChecksum(shardPath);
                 if (actualChecksum !== fileMeta.sha256Checksum) {
-                    console.warn(`File ${i + 1} checksum mismatch for ${fileMeta.filename}. Expected: ${fileMeta.sha256Checksum}. Actual: ${actualChecksum}. Will re-download.`);
+                    logger.warn(`File ${i + 1} checksum mismatch for ${fileMeta.filename}. Expected: ${fileMeta.sha256Checksum}. Actual: ${actualChecksum}. Will re-download.`);
                     invalidIndices.push(i);
                 }
             }

package/dist/server/utils/config-transform.d.ts

@@ -0,0 +1,3 @@
+import { type ModelTypeInput } from "../../schemas/index";
+export declare function transformConfigForReload(modelType: ModelTypeInput, config: unknown): unknown;
+//# sourceMappingURL=config-transform.d.ts.map