@qvac/sdk 0.3.0 → 0.4.0

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

@@ -15,12 +15,16 @@ 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);
@@ -226,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

@@ -11,6 +11,7 @@ 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;
@@ -25,5 +26,8 @@ export declare const handlers: {
     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

@@ -11,6 +11,9 @@ 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,
@@ -25,4 +28,7 @@ export const handlers = {
     loggingStream: handleLoggingStream,
     rag: handleRag,
     cancel: cancelHandler,
+    textToSpeech: handleTextToSpeech,
+    setConfig: handleSetConfig,
+    getModelInfo: handleGetModelInfo,
 };

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

@@ -4,6 +4,7 @@ import fetch from "bare-fetch";
 import { AbortController } from "bare-abort-controller";
 import { getModelsCacheDir, generateShortHash } from "../../../utils/index.js";
 import { getActiveDownload, registerDownload, unregisterDownload, createHttpDownloadKey, shouldClearCache, clearClearCacheFlag, } from "./download-manager.js";
+import { DownloadCancelledError, HTTPError, NoResponseBodyError, ResponseBodyNotReadableError, } from "../../../../utils/errors-server.js";
 function extractFilenameFromUrl(url) {
     // Parse URL to get the filename from the path
     const urlParts = url.split("/");
@@ -27,11 +28,10 @@ async function validateCachedFile(modelPath, url, signal) {
             expectedSize = parseInt(response.headers.get("content-length") || "0");
         }
         catch (error) {
-            console.log(`⚠️ Could not get expected file size from HEAD request: ${String(error)}`);
-            console.log(`✅ Using cached HTTP model: ${modelPath}`);
-            return modelPath;
+            console.log(`⚠️ Could not get expected file size from HEAD request, will re-download: ${String(error)}`);
+            return null;
         }
-        if (expectedSize > 0 && localSize !== expectedSize) {
+        if (localSize !== expectedSize) {
             console.log(`📥 Cached file size mismatch. Expected: ${expectedSize}, Found: ${localSize}. Re-downloading...`);
             return null;
         }
@@ -45,7 +45,7 @@ async function validateCachedFile(modelPath, url, signal) {
 }
 async function performHttpDownload(url, modelPath, downloadKey, progressCallback, signal) {
     if (signal?.aborted) {
-        throw new Error("Download cancelled");
+        throw new DownloadCancelledError();
     }
     console.log(`📥 Downloading model from HTTP: ${url}`);
     // Check if file exists for resuming
@@ -78,6 +78,16 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
         // Check if it's a 416 (Range Not Satisfiable) - file already complete
         if (response.status === 416 && startOffset > 0) {
             console.log(`✅ File already completely downloaded`);
+            // Send 100% progress for already complete file
+            if (progressCallback) {
+                progressCallback({
+                    type: "modelProgress",
+                    downloaded: startOffset,
+                    total: startOffset,
+                    percentage: 100,
+                    downloadKey,
+                });
+            }
             return;
         }
         // Check if server doesn't support range requests
@@ -94,14 +104,14 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                 ...(signal && { signal }),
             });
             if (!freshResponse.ok) {
-                throw new Error(`HTTP error: ${freshResponse.status} ${freshResponse.statusText}`);
+                throw new HTTPError(freshResponse.status, freshResponse.statusText);
             }
             // Use the fresh response
             Object.assign(response, freshResponse);
         }
         else if (response.status !== 206) {
             // 206 is Partial Content (successful resume)
-            throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
+            throw new HTTPError(response.status, response.statusText);
         }
     }
     // Get total size from headers
@@ -128,7 +138,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
     // Get the response body
     const body = response.body;
     if (!body) {
-        throw new Error("No response body received");
+        throw new NoResponseBodyError();
     }
     try {
         // Check if body has pipe method (it's a Node/Bare stream)
@@ -180,7 +190,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                 // Check if abort signal is triggered
                 if (signal && signal.aborted) {
                     writeStream.destroy();
-                    throw new Error("Download cancelled");
+                    throw new DownloadCancelledError();
                 }
                 const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
                 downloadedBytes += buffer.length;
@@ -259,7 +269,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                 });
             }
             else {
-                throw new Error("Response body is not readable");
+                throw new ResponseBodyNotReadableError();
             }
         }
     }
@@ -288,10 +298,41 @@ export async function downloadModelFromHttp(url, progressCallback) {
             // Check if already cached
             const cachedPath = await validateCachedFile(modelPath, url, abortController.signal);
             if (cachedPath) {
+                if (progressCallback) {
+                    try {
+                        const stats = await fsPromises.stat(cachedPath);
+                        progressCallback({
+                            type: "modelProgress",
+                            downloaded: stats.size,
+                            total: stats.size,
+                            percentage: 100,
+                            downloadKey,
+                        });
+                    }
+                    catch {
+                        // Ignore stat errors, file exists but might not be readable
+                    }
+                }
                 return cachedPath;
             }
             // Download the file
             await performHttpDownload(url, modelPath, downloadKey, progressCallback, abortController.signal);
+            // Send final 100% progress update
+            if (progressCallback) {
+                try {
+                    const stats = await fsPromises.stat(modelPath);
+                    progressCallback({
+                        type: "modelProgress",
+                        downloaded: stats.size,
+                        total: stats.size,
+                        percentage: 100,
+                        downloadKey,
+                    });
+                }
+                catch {
+                    // Ignore stat errors
+                }
+            }
             return modelPath;
         }
         catch (error) {