@qvac/sdk 0.2.7-dev.1761566029.f834aa3 → 0.4.0

package/dist/server/bare/rag-hyperdb/rag-manager.js

@@ -1,8 +1,8 @@
 import { RAG, HyperDBAdapter } from "@qvac/rag";
 import Corestore from "corestore";
 import path from "bare-path";
-import process from "bare-process";
 import { getEnv } from "../../worker.js";
+import { RAGWorkspaceModelMismatchError } from "../../../utils/errors-server.js";
 const ragInstances = new Map();
 const defaultWorkspace = "default";
 const getStorePath = (workspace) => {
@@ -15,9 +15,7 @@ export const getRagInstance = async (modelId, embeddingFunction, workspace) => {
     if (existingEntry) {
         // Validate model consistency
         if (existingEntry.modelId !== modelId) {
-            throw new Error(`Workspace "${key}" is configured for model "${existingEntry.modelId}", ` +
-                `but you're trying to use model "${modelId}". ` +
-                `Use a different workspace or the same model.`);
+            throw new RAGWorkspaceModelMismatchError(key, existingEntry.modelId, modelId);
         }
         return existingEntry.rag;
     }
@@ -48,14 +46,19 @@ export const closeRagInstance = async (workspace) => {
         ragInstances.delete(key);
     }
 };
+let isCleaningUp = false;
 export const closeAllRagInstances = async () => {
-    const closures = Array.from(ragInstances.entries()).map(async ([key, entry]) => {
-        await entry.rag.close();
-        ragInstances.delete(key);
-    });
-    await Promise.all(closures);
+    if (isCleaningUp)
+        return;
+    isCleaningUp = true;
+    try {
+        const closures = Array.from(ragInstances.entries()).map(async ([key, entry]) => {
+            await entry.rag.close();
+            ragInstances.delete(key);
+        });
+        await Promise.all(closures);
+    }
+    catch (error) {
+        console.error("❌ Error during RAG cleanup:", error);
+    }
 };
-// Ensure cleanup on process exit
-process.on("SIGINT", () => {
-    void closeAllRagInstances();
-});

package/dist/server/bare/registry/config-registry.d.ts

@@ -0,0 +1,5 @@
+import type { SDKConfig } from "../../../schemas/index";
+export declare const setSDKConfig: (config: SDKConfig) => void;
+export declare const getSDKConfig: () => SDKConfig;
+export declare const getConfiguredCacheDir: () => string;
+//# sourceMappingURL=config-registry.d.ts.map

package/dist/server/bare/registry/config-registry.js

@@ -0,0 +1,39 @@
+import fs from "bare-fs";
+import path from "bare-path";
+import { getEnv } from "../../worker.js";
+import { CacheDirNotAbsoluteError, CacheDirNotWritableError, } from "../../../utils/errors-server.js";
+const configRegistry = {
+    cacheDirectory: undefined,
+    swarmRelays: undefined,
+};
+export const setSDKConfig = (config) => {
+    if (config.cacheDirectory !== undefined && config.cacheDirectory !== null) {
+        if (!path.isAbsolute(config.cacheDirectory)) {
+            throw new CacheDirNotAbsoluteError();
+        }
+        try {
+            fs.mkdirSync(config.cacheDirectory, { recursive: true });
+            const testFile = path.join(config.cacheDirectory, ".qvac-test");
+            fs.writeFileSync(testFile, "test");
+            fs.unlinkSync(testFile);
+        }
+        catch (error) {
+            throw new CacheDirNotWritableError(config.cacheDirectory, error instanceof Error ? error.message : String(error), error);
+        }
+        configRegistry.cacheDirectory = config.cacheDirectory;
+        console.log(`✅ Cache directory set to: ${config.cacheDirectory}`);
+    }
+    if (config.swarmRelays !== undefined && config.swarmRelays !== null) {
+        configRegistry.swarmRelays = config.swarmRelays;
+    }
+};
+export const getSDKConfig = () => {
+    return { ...configRegistry };
+};
+const getDefaultCacheDir = () => {
+    const homeDir = getEnv().HOME_DIR;
+    return path.join(homeDir, ".qvac", "models");
+};
+export const getConfiguredCacheDir = () => {
+    return configRegistry.cacheDirectory || getDefaultCacheDir();
+};

package/dist/server/bare/registry/logging-stream-registry.d.ts

@@ -9,4 +9,5 @@ export declare function getLoggingStreamStats(): {
     modelIds: string[];
     totalStreams: number;
 };
+export declare function clearAllLoggingStreams(): void;
 //# sourceMappingURL=logging-stream-registry.d.ts.map

package/dist/server/bare/registry/logging-stream-registry.js

@@ -44,3 +44,10 @@ export function getLoggingStreamStats() {
         totalStreams: Array.from(loggingStreams.values()).reduce((sum, streams) => sum + streams.size, 0),
     };
 }
+export function clearAllLoggingStreams() {
+    const count = loggingStreams.size;
+    loggingStreams.clear();
+    if (count > 0) {
+        console.log(`🧹 Cleared logging streams for ${count} model(s)`);
+    }
+}

package/dist/server/bare/registry/model-registry.d.ts

@@ -1,4 +1,5 @@
 import type EventEmitter from "events";
+import type FilesystemDL from "@qvac/dl-filesystem";
 interface AddonInterface {
     cancel(jobId?: string): Promise<void>;
 }
@@ -8,6 +9,11 @@ export interface AnyModel {
         onUpdate(callback: (data: string) => void): {
             await: () => Promise<void>;
         };
+        onUpdate(callback: (data: {
+            outputArray: Int16Array;
+        }) => void): {
+            await: () => Promise<void>;
+        };
         onError(callback: (error: Error) => void): void;
         onUpdate(callback: (data: Array<{
             text: string;
@@ -20,6 +26,7 @@ export interface AnyModel {
         }>>;
         await(): Promise<void>;
     }>;
+    reload?(config: unknown): Promise<void>;
     unload?(): Promise<void>;
     addon?: AddonInterface;
 }
@@ -33,6 +40,8 @@ interface LocalOptions {
     path: string;
     loadedAt: Date;
     config: unknown;
+    name?: string | undefined;
+    loader: FilesystemDL;
 }
 export interface ModelEntry {
     id: string;
@@ -44,6 +53,8 @@ export declare function registerModel(id: string, options: {
     model: AnyModel;
     path: string;
     config: unknown;
+    loader: FilesystemDL;
+    name?: string | undefined;
 } | {
     topic: string;
     providerPublicKey: string;
@@ -59,8 +70,10 @@ export declare function getModelInfo(id: string): {
     path: string;
     loadedAt: Date;
     config: unknown;
+    name?: string;
 } | null;
 export declare function getModelConfig(id: string): unknown;
+export declare function updateModelConfig(id: string, config: unknown): void;
 export declare function clearRegistry(): void;
 export declare function getRegistryStats(): {
     totalModels: number;

package/dist/server/bare/registry/model-registry.js

@@ -1,8 +1,9 @@
+import { ModelAlreadyRegisteredError, ModelNotFoundError, ModelIsDelegatedError, } from "../../../utils/errors-server.js";
 // Global registry state - using stateless functions to manage it
 const modelRegistry = new Map();
 export function registerModel(id, options) {
     if (modelRegistry.has(id)) {
-        throw new Error(`Model with ID "${id}" is already registered`);
+        throw new ModelAlreadyRegisteredError(id);
     }
     const isDelegated = "topic" in options && "providerPublicKey" in options;
     if (isDelegated) {
@@ -27,9 +28,12 @@ export function registerModel(id, options) {
                 path: options.path,
                 loadedAt: new Date(),
                 config: options.config,
+                loader: options.loader,
+                name: options.name,
             },
         });
-        console.log(`Local model registered: ${id} -> ${options.path}`);
+        const nameStr = options.name ? ` (${options.name})` : "";
+        console.log(`Local model registered: ${id}${nameStr} -> ${options.path}`);
     }
 }
 export function getModelEntry(id) {
@@ -38,11 +42,10 @@ export function getModelEntry(id) {
 export function getModel(id) {
     const entry = modelRegistry.get(id);
     if (!entry) {
-        const availableIds = Array.from(modelRegistry.keys());
-        throw new Error(`Model with ID "${id}" not found in registry. Available models: ${availableIds.join(", ")}`);
+        throw new ModelNotFoundError(id);
     }
     if (!entry.local) {
-        throw new Error(`Model with ID "${id}" is delegated and cannot be accessed as a local model`);
+        throw new ModelIsDelegatedError(id);
     }
     return entry.local.model;
 }
@@ -66,20 +69,34 @@ export function getModelInfo(id) {
     if (!entry || !entry.local) {
         return null;
     }
-    return {
+    const result = {
         id: entry.id,
         path: entry.local.path,
         loadedAt: entry.local.loadedAt,
         config: entry.local.config,
     };
+    if (entry.local.name) {
+        result.name = entry.local.name;
+    }
+    return result;
 }
 export function getModelConfig(id) {
     const entry = modelRegistry.get(id);
     if (!entry || !entry.local) {
-        throw new Error(`Model with ID "${id}" not found or is delegated`);
+        throw new ModelNotFoundError(id);
     }
     return entry.local.config;
 }
+export function updateModelConfig(id, config) {
+    const entry = modelRegistry.get(id);
+    if (!entry) {
+        throw new ModelNotFoundError(id);
+    }
+    if (!entry.local) {
+        throw new ModelIsDelegatedError(id);
+    }
+    entry.local.config = config;
+}
 export function clearRegistry() {
     modelRegistry.clear();
     console.log("Model registry cleared");

package/dist/server/rpc/handle-request.js

@@ -12,14 +12,19 @@ import { handleTranslate } from "./handlers/translate.js";
 import { handleLoggingStream } from "./handlers/logging-stream.js";
 import { cancelHandler } from "./handlers/cancelHandler.js";
 import { provideHandler } from "./handlers/provideHandler.js";
+import { stopProvideHandler } from "./handlers/stopProvideHandler.js";
 import { handleRag } from "./handlers/rag.js";
 import { handleDeleteCache } from "./handlers/delete-cache.js";
-import { sendErrorResponse, sendStreamErrorResponse } from "../error-handlers";
+import { handleTextToSpeech } from "./handlers/text-to-speech.js";
+import { handleSetConfig } from "./handlers/set-config.js";
+import { handleGetModelInfo } from "./handlers/get-model-info.js";
+import { sendErrorResponse, sendStreamErrorResponse, } from "../error-handlers.js";
+import { NoDataReceivedError, UnknownRequestTypeError, } from "../../utils/errors-client.js";
 export async function handleRequest(req) {
     try {
         const rawData = req.data?.toString();
         if (!rawData) {
-            throw new Error("No data received");
+            throw new NoDataReceivedError();
         }
         const jsonData = JSON.parse(rawData);
         const request = requestSchema.parse(jsonData);
@@ -200,6 +205,11 @@ export async function handleRequest(req) {
                 req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
                 break;
             }
+            case "stopProvide": {
+                const response = stopProvideHandler(request);
+                req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                break;
+            }
             case "rag": {
                 try {
                     const response = await handleRag(request);
@@ -220,8 +230,43 @@ export async function handleRequest(req) {
                 }
                 break;
             }
+            case "textToSpeech": {
+                const stream = req.createResponseStream();
+                try {
+                    for await (const response of handleTextToSpeech(request)) {
+                        const validatedResponse = responseSchema.parse(response);
+                        const data = JSON.stringify(validatedResponse);
+                        stream.write(data + "\n", "utf-8");
+                    }
+                    stream.end();
+                }
+                catch (error) {
+                    sendStreamErrorResponse(stream, error);
+                }
+                break;
+            }
+            case "setConfig": {
+                try {
+                    const response = handleSetConfig(request);
+                    req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                }
+                catch (error) {
+                    sendErrorResponse(req, error);
+                }
+                break;
+            }
+            case "getModelInfo": {
+                try {
+                    const response = await handleGetModelInfo(request);
+                    req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                }
+                catch (error) {
+                    sendErrorResponse(req, error);
+                }
+                break;
+            }
             default: {
-                throw new Error(`Unknown request type`);
+                throw new UnknownRequestTypeError();
             }
         }
     }

package/dist/server/rpc/handlers/completion-stream-delegated.js

@@ -1,11 +1,12 @@
 import { getModelEntry } from "../../bare/registry/model-registry.js";
 import { getRPC } from "../../bare/delegate-rpc-client.js";
 import { stream } from "../../../client/rpc/rpc-client.js";
+import { ModelIsDelegatedError } from "../../../utils/errors-server.js";
 export async function* handleCompletionStreamDelegated(request) {
     // Get delegation info from model registry
     const entry = getModelEntry(request.modelId);
     if (!entry?.isDelegated || !entry.delegated) {
-        throw new Error(`Model ${request.modelId} is not a delegated model`);
+        throw new ModelIsDelegatedError(request.modelId);
     }
     const { topic, providerPublicKey, timeout } = entry.delegated;
     try {

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

@@ -9,30 +9,37 @@ export async function* handleCompletionStream(request) {
         history: filteredHistory,
         modelId: request.modelId,
         kvCache: request.kvCache,
+        ...(request.tools && { tools: request.tools }),
     });
     let stats;
+    let toolCalls = [];
     let done = false;
     let buffer = "";
     while (!done) {
         const result = await stream.next();
         if (result.done) {
-            stats = result.value;
+            stats = result.value.stats;
+            toolCalls = result.value.toolCalls;
             done = true;
         }
         else {
-            buffer += result.value;
             if (request.stream) {
                 yield {
                     type: "completionStream",
-                    token: result.value,
+                    token: result.value.token,
+                    toolCallEvent: result.value.toolCallEvent,
                 };
             }
+            else {
+                buffer += result.value.token;
+            }
         }
     }
     yield {
         type: "completionStream",
-        token: buffer,
+        token: request.stream ? "" : buffer,
         done: true,
         stats,
+        toolCalls,
     };
 }

package/dist/server/rpc/handlers/download-asset.js

@@ -1,13 +1,12 @@
 import { resolveModelPath } from "./load-model/resolve.js";
-import path from "bare-path";
 export async function handleDownloadAsset(request, progressCallback) {
     const { assetSrc, seed } = request;
     try {
-        const assetPath = await resolveModelPath(assetSrc, progressCallback, seed);
+        await resolveModelPath(assetSrc, progressCallback, seed);
         return {
             type: "downloadAsset",
             success: true,
-            assetId: path.basename(assetPath),
+            assetId: assetSrc,
         };
     }
     catch (error) {

package/dist/server/rpc/handlers/get-model-info.d.ts

@@ -0,0 +1,3 @@
+import type { GetModelInfoRequest, GetModelInfoResponse } from "../../../schemas/index";
+export declare const handleGetModelInfo: (request: GetModelInfoRequest) => Promise<GetModelInfoResponse>;
+//# sourceMappingURL=get-model-info.d.ts.map

package/dist/server/rpc/handlers/get-model-info.js

@@ -0,0 +1,148 @@
+import { models } from "../../../models/hyperdrive/models.js";
+import { getAllModelIds, getModelEntry, } from "../../bare/registry/model-registry.js";
+import { getConfiguredCacheDir } from "../../bare/registry/config-registry.js";
+import { generateShortHash } from "../../utils/index.js";
+import { promises as fsPromises } from "bare-fs";
+import path from "bare-path";
+import { getShardPath } from "../../utils/cache.js";
+import { ModelNotFoundError } from "../../../utils/errors-server.js";
+export const handleGetModelInfo = async (request) => {
+    const { name } = request;
+    const catalogEntry = models.find((m) => m.name === name);
+    if (!catalogEntry) {
+        throw new ModelNotFoundError(`${name}" not found in catalog. Use model names from the catalog (e.g., "WHISPER_TINY", "EMBEDDINGGEMMA_300M_Q4_0")`);
+    }
+    const cacheStatus = catalogEntry.shardMetadata && catalogEntry.shardMetadata.length > 0
+        ? await handleShardedModel(catalogEntry.hyperdriveKey, catalogEntry.shardMetadata)
+        : await handleSingleFileModel(catalogEntry.hyperdriveKey, catalogEntry.modelId, catalogEntry.expectedSize, catalogEntry.sha256Checksum);
+    const { cacheFiles, isCached, actualSize, cachedAt } = cacheStatus;
+    const loadedModelIds = getAllModelIds();
+    const loadedInstances = [];
+    for (const id of loadedModelIds) {
+        const entry = getModelEntry(id);
+        if (!entry?.local)
+            continue;
+        const matchesByName = entry.local.name && entry.local.name === name;
+        const matchesByPath = cacheFiles.length > 0 && entry.local.path === cacheFiles[0]?.path;
+        if (matchesByName || matchesByPath) {
+            const instance = {
+                registryId: id,
+                loadedAt: entry.local.loadedAt,
+                config: entry.local.config,
+            };
+            loadedInstances.push(instance);
+        }
+    }
+    const isLoaded = loadedInstances.length > 0;
+    const modelInfo = {
+        name: catalogEntry.name,
+        modelId: catalogEntry.modelId,
+        hyperdriveKey: catalogEntry.hyperdriveKey,
+        hyperbeeKey: catalogEntry.hyperbeeKey,
+        expectedSize: catalogEntry.expectedSize,
+        sha256Checksum: catalogEntry.sha256Checksum,
+        addon: catalogEntry.addon,
+        isCached,
+        isLoaded,
+        cacheFiles,
+        actualSize,
+        cachedAt,
+        loadedInstances: loadedInstances.length > 0 ? loadedInstances : undefined,
+    };
+    return {
+        type: "getModelInfo",
+        modelInfo,
+    };
+};
+async function handleShardedModel(hyperdriveKey, shardMetadata) {
+    const cacheFiles = [];
+    let allShardsCached = true;
+    let totalActualSize = 0;
+    let latestCachedAt;
+    for (const shard of shardMetadata) {
+        const shardPath = getShardPath(hyperdriveKey, shard.filename);
+        let shardIsCached = false;
+        let shardActualSize;
+        let shardCachedAt;
+        try {
+            const stats = await fsPromises.stat(shardPath);
+            shardIsCached = stats.isFile();
+            if (shardIsCached) {
+                shardActualSize = stats.size;
+                shardCachedAt = stats.mtime;
+                totalActualSize += stats.size;
+                if (!latestCachedAt || stats.mtime > latestCachedAt) {
+                    latestCachedAt = stats.mtime;
+                }
+            }
+            else {
+                allShardsCached = false;
+            }
+        }
+        catch {
+            shardIsCached = false;
+            allShardsCached = false;
+        }
+        cacheFiles.push({
+            filename: shard.filename,
+            path: shardPath,
+            expectedSize: shard.expectedSize,
+            sha256Checksum: shard.sha256Checksum,
+            isCached: shardIsCached,
+            actualSize: shardActualSize,
+            cachedAt: shardCachedAt,
+        });
+    }
+    const result = {
+        cacheFiles,
+        isCached: allShardsCached,
+    };
+    if (allShardsCached) {
+        result.actualSize = totalActualSize;
+        if (latestCachedAt) {
+            result.cachedAt = latestCachedAt;
+        }
+    }
+    return result;
+}
+async function handleSingleFileModel(hyperdriveKey, modelId, expectedSize, sha256Checksum) {
+    const cacheDir = getConfiguredCacheDir();
+    const sourceHash = generateShortHash(`${hyperdriveKey}/${modelId}`);
+    const filePath = path.join(cacheDir, `${sourceHash}_${modelId}`);
+    let fileIsCached = false;
+    let fileActualSize;
+    let fileCachedAt;
+    try {
+        const stats = await fsPromises.stat(filePath);
+        fileIsCached = stats.isFile();
+        if (fileIsCached) {
+            fileActualSize = stats.size;
+            fileCachedAt = stats.mtime;
+        }
+    }
+    catch {
+        fileIsCached = false;
+    }
+    const cacheFiles = [
+        {
+            filename: modelId,
+            path: filePath,
+            expectedSize,
+            sha256Checksum,
+            isCached: fileIsCached,
+            actualSize: fileActualSize,
+            cachedAt: fileCachedAt,
+        },
+    ];
+    const result = {
+        cacheFiles,
+        isCached: fileIsCached,
+    };
+    if (fileActualSize !== undefined) {
+        result.actualSize = fileActualSize;
+    }
+    if (fileCachedAt !== undefined) {
+        result.cachedAt = fileCachedAt;
+    }
+    return result;
+}

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

@@ -5,11 +5,13 @@ import { handleUnloadModel } from "./unload-model";
 import { handleEmbed } from "./embed";
 import { handleTranscribeStream } from "./transcribe-stream";
 import { provideHandler } from "./provideHandler";
+import { stopProvideHandler } from "./stopProvideHandler";
 import { handleTranslate } from "./translate";
 import { handleLoggingStream } from "./logging-stream";
 import { handleRag } from "./rag";
 import { cancelHandler } from "./cancelHandler";
 import { handleDeleteCache } from "./delete-cache";
+import { handleTextToSpeech } from "./text-to-speech";
 export declare const handlers: {
     completionStream: typeof handleCompletionStream;
     downloadAsset: typeof handleDownloadAsset;
@@ -19,9 +21,13 @@ export declare const handlers: {
     embed: typeof handleEmbed;
     transcribeStream: typeof handleTranscribeStream;
     provide: typeof provideHandler;
+    stopProvide: typeof stopProvideHandler;
     translate: typeof handleTranslate;
     loggingStream: typeof handleLoggingStream;
     rag: typeof handleRag;
     cancel: typeof cancelHandler;
+    textToSpeech: typeof handleTextToSpeech;
+    setConfig: (request: import("../../../schemas").SetConfigRequest) => import("../../../schemas").SetConfigResponse;
+    getModelInfo: (request: import("../../../schemas").GetModelInfoRequest) => Promise<import("../../../schemas").GetModelInfoResponse>;
 };
 //# sourceMappingURL=index.d.ts.map

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

@@ -5,11 +5,15 @@ import { handleUnloadModel } from "./unload-model.js";
 import { handleEmbed } from "./embed.js";
 import { handleTranscribeStream } from "./transcribe-stream.js";
 import { provideHandler } from "./provideHandler.js";
+import { stopProvideHandler } from "./stopProvideHandler.js";
 import { handleTranslate } from "./translate.js";
 import { handleLoggingStream } from "./logging-stream.js";
 import { handleRag } from "./rag.js";
 import { cancelHandler } from "./cancelHandler.js";
 import { handleDeleteCache } from "./delete-cache.js";
+import { handleTextToSpeech } from "./text-to-speech.js";
+import { handleSetConfig } from "./set-config.js";
+import { handleGetModelInfo } from "./get-model-info.js";
 export const handlers = {
     completionStream: handleCompletionStream,
     downloadAsset: handleDownloadAsset,
@@ -19,8 +23,12 @@ export const handlers = {
     embed: handleEmbed,
     transcribeStream: handleTranscribeStream,
     provide: provideHandler,
+    stopProvide: stopProvideHandler,
     translate: handleTranslate,
     loggingStream: handleLoggingStream,
     rag: handleRag,
     cancel: cancelHandler,
+    textToSpeech: handleTextToSpeech,
+    setConfig: handleSetConfig,
+    getModelInfo: handleGetModelInfo,
 };

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

@@ -9,4 +9,5 @@ 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 cleanupDownloads: () => Promise<void>;
 //# sourceMappingURL=download-manager.d.ts.map