@qvac/sdk 0.8.1 → 1.0.0

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

@@ -1,67 +1,9 @@
-import { chunk, ingest, reindex, saveEmbeddings, search, deleteEmbeddings, listWorkspaces, closeWorkspace, deleteWorkspace, DEFAULT_WORKSPACE, registerRagOperation, unregisterRagOperation, } from "../../bare/rag-hyperdb/index.js";
-import { profileReplyHandler, registerOperationMetrics, } from "../profiling/index.js";
-registerOperationMetrics({
-    op: "rag",
-    kind: "handler",
-    getTags: (req) => {
-        const tags = {};
-        if (req.operation)
-            tags["operation"] = req.operation;
-        if (req.workspace)
-            tags["workspace"] = req.workspace;
-        return tags;
-    },
-    fromResult: (res) => {
-        const gauges = {};
-        if (res.processed !== undefined)
-            gauges["processed"] = res.processed.length;
-        if (res.results !== undefined)
-            gauges["resultsCount"] = res.results.length;
-        return Object.keys(gauges).length > 0 ? gauges : undefined;
-    },
-});
-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) {
-    return profileReplyHandler({ op: "rag", request }, async () => handleRagInternal(request, onProgress));
-}
-async function handleRagInternal(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);
+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);
                 return {
                     type: "rag",
                     operation: request.operation,
@@ -70,85 +12,56 @@ async function handleRagInternal(request, onProgress) {
                     droppedIndices: result.droppedIndices,
                 };
             }
-            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);
+            case "search": {
+                const results = await search(request);
                 return {
                     type: "rag",
                     operation: request.operation,
                     success: true,
-                    processed,
+                    results,
                 };
             }
-            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);
+            case "deleteEmbeddings": {
+                const success = await deleteEmbeddings(request);
                 return {
                     type: "rag",
                     operation: request.operation,
-                    success: true,
-                    result,
+                    success,
                 };
             }
-            finally {
-                unregisterRagOperation(workspace);
+            default: {
+                throw new Error(`Unknown RAG operation`);
             }
         }
-        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,
-            };
+    }
+    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;
         }
     }
 }

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

@@ -1,20 +1,16 @@
-import { getSwarm, unregisterProviderTopic } from "../../bare/hyperswarm.js";
-import { getServerLogger } from "../../../logging/index.js";
-const logger = getServerLogger();
+import { getSwarm } from "../../bare/hyperswarm.js";
 export function stopProvideHandler(request) {
     const swarm = getSwarm();
     try {
         const topic = Buffer.from(request.topic, "hex");
-        const topicHex = request.topic;
         swarm.leave(topic);
-        unregisterProviderTopic(topicHex);
         return {
             type: "stopProvide",
             success: true,
         };
     }
     catch (error) {
-        logger.error("❌ Error in stop provide handler:", error);
+        console.error("❌ Error in stop provide handler:", error);
         return {
             type: "stopProvide",
             success: false,

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

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

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

@@ -1,4 +1,26 @@
-import { dispatchPluginStream } from "./plugin-dispatch.js";
+import { transcribeStream } from "../../bare/addons/whispercpp/index.js";
 export async function* handleTranscribeStream(request) {
-    yield* dispatchPluginStream(request.modelId, "transcribeStream", request);
+    const { modelId, audioChunk } = request;
+    try {
+        // Stream transcription results in real-time
+        for await (const textChunk of transcribeStream({ audioChunk, modelId })) {
+            yield {
+                type: "transcribeStream",
+                text: textChunk,
+            };
+        }
+        // Signal completion
+        yield {
+            type: "transcribeStream",
+            done: true,
+        };
+    }
+    catch (error) {
+        console.error("Error during transcription:", error);
+        yield {
+            type: "transcribeStream",
+            text: "",
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
 }

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

@@ -1,4 +1,51 @@
-import { dispatchPluginStream } from "./plugin-dispatch.js";
+import { translate } from "../../bare/addons/translation/index.js";
 export async function* handleTranslate(request) {
-    yield* dispatchPluginStream(request.modelId, "translate", 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,
+        });
+        let stats;
+        let done = false;
+        let buffer = "";
+        while (!done) {
+            const result = await generator.next();
+            if (result.done) {
+                stats = result.value;
+                done = true;
+            }
+            else {
+                buffer += result.value;
+                if (stream) {
+                    yield {
+                        type: "translate",
+                        token: result.value,
+                    };
+                }
+            }
+        }
+        yield {
+            type: "translate",
+            token: buffer,
+            done: true,
+            stats,
+        };
+    }
+    catch (error) {
+        console.error("Error during translation:", error);
+        yield {
+            type: "translate",
+            token: "",
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
 }

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

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

package/dist/server/rpc/index.d.ts

@@ -1,3 +1,3 @@
 export { createBareKitRPCServer, createIPCClient } from "./create-server";
-export { handleRequest } from "./handle-request";
+export { handleRequest, type BareRPCRequest } from "./handle-request";
 //# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,20 +1,17 @@
 import fs from "bare-fs";
 import path from "bare-path";
-import { FFmpegDecoder } from "@qvac/decoder-audio";
-import { FORMATS_NEEDING_DECODE } from "@qvac/decoder-audio/constants.js";
+import GSTDecoder from "@qvac/decoder-audio";
 import { Readable } from "bare-stream";
-import { getServerLogger } from "../../../logging/index.js";
-import {} from "../../../schemas/index.js";
-const logger = getServerLogger();
+import { FORMATS_NEEDING_DECODE } from "../../../constants/audio.js";
 export function needsDecoding(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     return FORMATS_NEEDING_DECODE.includes(ext);
 }
-const DECODER_TIMEOUT_MS = 10000;
-export async function decodeAudioToStream(inputPath, audioFormat = "s16le") {
-    const decoder = new FFmpegDecoder({
-        config: { audioFormat },
-        logger,
+export async function decodeAudioToStream(inputPath) {
+    const decoder = new GSTDecoder({
+        config: {
+            audioFormat: "encoded",
+        },
     });
     try {
         await decoder.load();
@@ -23,56 +20,22 @@ export async function decodeAudioToStream(inputPath, audioFormat = "s16le") {
         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(() => {
-            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);
-                }
-            }
+            outputStream.push(null);
         })
-            .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)));
-            }
+            .await()
+            .catch((error) => {
+            outputStream.destroy(error instanceof Error ? error : new Error(String(error)));
         });
         return outputStream;
     }
     catch (error) {
-        await decoder.unload();
-        logger.error("Decoding failed:", error instanceof Error ? error.message : String(error));
+        console.error("Decoding failed:", error instanceof Error ? error.message : String(error));
         throw error;
     }
 }

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

@@ -1,26 +1,15 @@
-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>/
- */
-export declare function getShardedModelCacheDir(hyperdriveKey: string): string;
 /**
- * Get full path to ONNX file in cache
- * Returns: cache/onnx/<cacheKey>/<filename>
+ * Creates and returns cache directory path for the specified subdirectory
+ * @param subDir - Subdirectory name (e.g., "models", "kv-cache")
+ * @returns Full path to the cache directory
  */
-export declare function getOnnxModelPath(cacheKey: string, filename: string): string;
+export declare function getCacheDir(subDir: string): string;
 /**
- * Get full path to specific shard file
- * Returns: cache/sharded/<hyperdriveKey>/<shardFilename>
+ * Legacy function for backward compatibility - gets models cache directory
  */
-export declare function getShardPath(hyperdriveKey: string, shardFilename: string): string;
+export declare function getModelsCacheDir(): string;
 /**
- * Check if all shards exist and are valid (size + checksum check)
- * Returns array of missing/invalid shard indices (0-based)
- * @param onChecksumTimeMs - Optional callback to report checksum validation time
+ * Gets KV cache directory
  */
-export declare function checkShardCompleteness(hyperdriveKey: string, shardFilenames: readonly string[], shardMetadata: readonly ShardFileMetadata[], onChecksumTimeMs?: (ms: number) => void): Promise<number[]>;
+export declare function getKVCacheDir(): string;
 //# sourceMappingURL=cache.d.ts.map

package/dist/server/utils/cache.js

@@ -1,117 +1,32 @@
-import fs, { promises as fsPromises } from "bare-fs";
+import fs from "bare-fs";
 import path from "bare-path";
-import { getEnv } from "../env.js";
-import { getConfiguredCacheDir } from "../bare/registry/config-registry.js";
-import { calculateFileChecksum } from "./checksum.js";
-import { validateAndJoinPath } from "./path-security.js";
-import { getServerLogger } from "../../logging/index.js";
-import { nowMs } from "../../profiling/index.js";
-const logger = getServerLogger();
+import { getEnv } from "../worker.js";
+/**
+ * Creates and returns cache directory path for the specified subdirectory
+ * @param subDir - Subdirectory name (e.g., "models", "kv-cache")
+ * @returns Full path to the cache directory
+ */
 export function getCacheDir(subDir) {
     const homeDir = getEnv().HOME_DIR;
     const cacheDir = path.join(homeDir, ".qvac", subDir);
+    // Ensure cache directory exists
     try {
         fs.mkdirSync(cacheDir, { recursive: true });
     }
     catch (error) {
-        logger.error(`Error creating cache directory (${subDir}):`, error instanceof Error ? error.message : String(error));
+        console.error(`Error creating cache directory (${subDir}):`, error instanceof Error ? error.message : String(error));
     }
     return cacheDir;
 }
-export function getModelsCacheDir() {
-    const configuredDir = getConfiguredCacheDir();
-    try {
-        fs.mkdirSync(configuredDir, { recursive: true });
-    }
-    catch (error) {
-        logger.error(`Error creating models cache directory:`, error instanceof Error ? error.message : String(error));
-    }
-    return configuredDir;
-}
-export function getKVCacheDir() {
-    return getCacheDir("kv-cache");
-}
-/**
- * Get cache directory for sharded model
- * Returns: cache/sharded/<hyperdriveKey>/
- */
-export function getShardedModelCacheDir(hyperdriveKey) {
-    const baseCache = getModelsCacheDir();
-    const shardDir = path.join(baseCache, "sharded", hyperdriveKey);
-    try {
-        fs.mkdirSync(shardDir, { recursive: true });
-    }
-    catch (error) {
-        logger.error(`Error creating sharded model cache directory:`, error instanceof Error ? error.message : String(error));
-    }
-    return shardDir;
-}
-/**
- * Get cache directory for ONNX model with external data
- * Returns: cache/onnx/<cacheKey>/
- */
-function getOnnxModelCacheDir(cacheKey) {
-    const baseCache = getModelsCacheDir();
-    const onnxDir = validateAndJoinPath(baseCache, "onnx", cacheKey);
-    try {
-        fs.mkdirSync(onnxDir, { recursive: true });
-    }
-    catch (error) {
-        logger.error(`Error creating ONNX model cache directory:`, error instanceof Error ? error.message : String(error));
-    }
-    return onnxDir;
-}
-/**
- * Get full path to ONNX file in cache
- * Returns: cache/onnx/<cacheKey>/<filename>
- */
-export function getOnnxModelPath(cacheKey, filename) {
-    const onnxDir = getOnnxModelCacheDir(cacheKey);
-    return validateAndJoinPath(onnxDir, filename);
-}
 /**
- * Get full path to specific shard file
- * Returns: cache/sharded/<hyperdriveKey>/<shardFilename>
+ * Legacy function for backward compatibility - gets models cache directory
  */
-export function getShardPath(hyperdriveKey, shardFilename) {
-    const shardDir = getShardedModelCacheDir(hyperdriveKey);
-    return validateAndJoinPath(shardDir, shardFilename);
+export function getModelsCacheDir() {
+    return getCacheDir("models");
 }
 /**
- * Check if all shards exist and are valid (size + checksum check)
- * Returns array of missing/invalid shard indices (0-based)
- * @param onChecksumTimeMs - Optional callback to report checksum validation time
+ * Gets KV cache directory
  */
-export async function checkShardCompleteness(hyperdriveKey, shardFilenames, shardMetadata, onChecksumTimeMs) {
-    const invalidIndices = [];
-    for (let i = 0; i < shardFilenames.length; i++) {
-        const shardPath = getShardPath(hyperdriveKey, shardFilenames[i]);
-        const fileMeta = shardMetadata[i];
-        if (!fileMeta) {
-            invalidIndices.push(i);
-            continue;
-        }
-        try {
-            const stats = await fsPromises.stat(shardPath);
-            if (stats.size !== fileMeta.expectedSize) {
-                logger.warn(`File ${i + 1} size mismatch: expected ${fileMeta.expectedSize}, got ${stats.size}`);
-                invalidIndices.push(i);
-                continue;
-            }
-            if (fileMeta.sha256Checksum) {
-                const start = nowMs();
-                const actualChecksum = await calculateFileChecksum(shardPath);
-                onChecksumTimeMs?.(nowMs() - start);
-                if (actualChecksum !== fileMeta.sha256Checksum) {
-                    logger.warn(`File ${i + 1} checksum mismatch for ${fileMeta.filename}. Expected: ${fileMeta.sha256Checksum}. Actual: ${actualChecksum}. Will re-download.`);
-                    invalidIndices.push(i);
-                }
-            }
-        }
-        catch {
-            // File doesn't exist
-            invalidIndices.push(i);
-        }
-    }
-    return invalidIndices;
+export function getKVCacheDir() {
+    return getCacheDir("kv-cache");
 }

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

@@ -0,0 +1,5 @@
+/**
+ * Generate a short hash (16 characters) from any input string
+ */
+export declare function generateShortHash(input: string): string;
+//# sourceMappingURL=hash.d.ts.map

package/dist/server/utils/hash.js

@@ -0,0 +1,11 @@
+import crypto from "bare-crypto";
+/**
+ * Generate a short hash (16 characters) from any input string
+ */
+export function generateShortHash(input) {
+    const hash = crypto
+        .createHash("sha256")
+        .update(Buffer.from(input, "utf8"))
+        .digest("hex");
+    return hash.substring(0, 16);
+}

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

@@ -1,10 +1,5 @@
-export * from "./archive";
+export * from "./audio/decoder";
 export * from "./cache";
-export * from "./checksum";
-export * from "./config-transform";
-export * from "./formatting";
-export * from "./gguf-tensor-extractor";
+export * from "./hash";
 export * from "./model-path";
-export * from "./path-security";
-export * from "./shard-utils";
 //# sourceMappingURL=index.d.ts.map

package/dist/server/utils/index.js

@@ -1,9 +1,4 @@
-export * from "./archive.js";
+export * from "./audio/decoder.js";
 export * from "./cache.js";
-export * from "./checksum.js";
-export * from "./config-transform.js";
-export * from "./formatting.js";
-export * from "./gguf-tensor-extractor.js";
+export * from "./hash.js";
 export * from "./model-path.js";
-export * from "./path-security.js";
-export * from "./shard-utils.js";