@qvac/sdk 0.9.2 → 0.10.1

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

@@ -8,14 +8,13 @@ export async function* handleCompletionStreamDelegated(request, options) {
     const { profilingMeta } = options ?? {};
     // Get delegation info from model registry
     const entry = getModelEntry(request.modelId);
-    if (!entry?.isDelegated || !entry.delegated) {
+    if (!entry?.isDelegated) {
         throw new ModelIsDelegatedError(request.modelId);
     }
-    const { topic, providerPublicKey, timeout, healthCheckTimeout } = entry.delegated;
+    const { providerPublicKey, timeout, healthCheckTimeout } = entry.delegated;
     try {
         logger.debug(`📤 Sending delegated completionStream request to provider: ${providerPublicKey}${timeout ? `, timeout: ${timeout}ms` : ""}`);
-        // Create RPC instance for this HyperSwarm peer
-        const rpc = await getRPC(topic, providerPublicKey, { timeout, healthCheckTimeout });
+        const rpc = await getRPC(providerPublicKey, { timeout, healthCheckTimeout });
         // Build delegate options with profiling metadata
         const delegateOpts = { peerKey: providerPublicKey };
         if (profilingMeta) {
@@ -33,10 +32,20 @@ export async function* handleCompletionStreamDelegated(request, options) {
     }
     catch (error) {
         logger.error("Error in delegated completion stream:", error);
+        const message = error instanceof Error ? error.message : String(error);
         yield {
             type: "completionStream",
-            token: `Error communicating with provider: ${error instanceof Error ? error.message : String(error)}`,
             done: true,
+            events: [
+                {
+                    type: "completionDone",
+                    seq: 0,
+                    stopReason: "error",
+                    error: {
+                        message: `Error communicating with provider: ${message}`,
+                    },
+                },
+            ],
         };
     }
 }

package/dist/server/rpc/handlers/delete-cache.js

@@ -1,4 +1,4 @@
-import { deleteCache as deleteCacheUtil } from "../../bare/ops/kv-cache-utils.js";
+import { clearCacheRegistry, deleteCache as deleteCacheUtil, } from "../../bare/ops/kv-cache-utils.js";
 import { clearCachedMessageCounts } from "../../bare/plugins/llamacpp-completion/ops/completion-stream.js";
 import { getServerLogger } from "../../../logging/index.js";
 const logger = getServerLogger();
@@ -7,6 +7,7 @@ export async function handleDeleteCache(request) {
         if ("all" in request && request.all) {
             await deleteCacheUtil({ all: true });
             clearCachedMessageCounts();
+            clearCacheRegistry();
         }
         else if ("kvCacheKey" in request) {
             const params = {
@@ -15,8 +16,12 @@ export async function handleDeleteCache(request) {
             if (request.modelId !== undefined) {
                 params.modelId = request.modelId;
             }
-            await deleteCacheUtil(params);
-            clearCachedMessageCounts();
+            const removedPath = await deleteCacheUtil(params);
+            clearCachedMessageCounts(removedPath);
+            clearCacheRegistry({
+                cacheKey: request.kvCacheKey,
+                modelId: request.modelId,
+            });
         }
         return {
             type: "deleteCache",

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

@@ -1,5 +1,6 @@
 import { PROFILING_KEY, OPERATION_EVENT_KEY, } from "../../../schemas/index.js";
 import { resolveModelPath, resolveModelPathWithStats, } from "./load-model/resolve.js";
+import { buildDownloadProfilingFields } from "./load-model/types.js";
 import { nowMs, generateProfileId } from "../../../profiling/clock.js";
 import { getServerLogger } from "../../../logging/index.js";
 const logger = getServerLogger();
@@ -27,30 +28,8 @@ export async function handleDownloadAsset(request, progressCallback) {
         if (profilingEnabled) {
             const totalDownloadTimeMs = nowMs() - totalDownloadStart;
             const profileId = profilingMeta?.id ?? generateProfileId();
-            const gauges = {
-                totalDownloadTime: totalDownloadTimeMs,
-            };
-            if (downloadStats) {
-                if (downloadStats.downloadTimeMs !== undefined) {
-                    gauges["downloadTime"] = downloadStats.downloadTimeMs;
-                }
-                if (downloadStats.totalBytesDownloaded !== undefined) {
-                    gauges["totalBytesDownloaded"] = downloadStats.totalBytesDownloaded;
-                }
-                if (downloadStats.downloadSpeedBps !== undefined) {
-                    gauges["downloadSpeedBps"] = downloadStats.downloadSpeedBps;
-                }
-                if (downloadStats.checksumValidationTimeMs !== undefined) {
-                    gauges["checksumValidationTime"] = downloadStats.checksumValidationTimeMs;
-                }
-            }
-            const tags = {};
-            if (sourceType) {
-                tags["sourceType"] = sourceType;
-            }
-            if (downloadStats?.cacheHit !== undefined) {
-                tags["cacheHit"] = downloadStats.cacheHit ? "true" : "false";
-            }
+            const { gauges, tags } = buildDownloadProfilingFields(downloadStats, sourceType);
+            gauges["totalDownloadTime"] = totalDownloadTimeMs;
             const operationEvent = {
                 op: "downloadAsset",
                 kind: "handler",

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

@@ -0,0 +1,3 @@
+import type { GetLoadedModelInfoRequest, GetLoadedModelInfoResponse } from "../../../schemas/index";
+export declare function handleGetLoadedModelInfo(request: GetLoadedModelInfoRequest): GetLoadedModelInfoResponse;
+//# sourceMappingURL=get-loaded-model-info.d.ts.map

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

@@ -0,0 +1,39 @@
+import { getModelEntry } from "../../bare/registry/model-registry.js";
+import { getPlugin } from "../../plugins/registry.js";
+import { ModelNotFoundError } from "../../../utils/errors-server.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
+export function handleGetLoadedModelInfo(request) {
+    const { modelId } = request;
+    const entry = getModelEntry(modelId);
+    if (!entry) {
+        throw new ModelNotFoundError(modelId);
+    }
+    if (entry.isDelegated) {
+        const info = {
+            modelId: entry.id,
+            isDelegated: true,
+            handlers: [],
+            providerInfo: {
+                providerPublicKey: entry.delegated.providerPublicKey,
+            },
+        };
+        return { type: "getLoadedModelInfo", info };
+    }
+    const plugin = getPlugin(entry.local.modelType);
+    if (!plugin) {
+        logger.warn(`getLoadedModelInfo: no plugin registered for modelType "${entry.local.modelType}" on loaded model "${modelId}"`);
+    }
+    const info = {
+        modelId: entry.id,
+        isDelegated: false,
+        modelType: entry.local.modelType,
+        handlers: plugin ? Object.keys(plugin.handlers) : [],
+        loadedAt: entry.local.loadedAt,
+        ...(plugin && { displayName: plugin.displayName }),
+        ...(plugin && { addonPackage: plugin.addonPackage }),
+        ...(entry.local.name && { name: entry.local.name }),
+        ...(entry.local.path && { path: entry.local.path }),
+    };
+    return { type: "getLoadedModelInfo", info };
+}

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

@@ -1,10 +1,9 @@
 import { models } from "../../../models/registry/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 { getShardPath, getModelsCacheDir, getSingleFileCachePath, } from "../../utils/cache/paths.js";
+import { validateAndJoinPath } from "../../utils/path-security.js";
 import { ModelNotFoundError } from "../../../utils/errors-server.js";
 export async function handleGetModelInfo(request) {
     const { name } = request;
@@ -15,16 +14,19 @@ export async function handleGetModelInfo(request) {
     const cacheKey = generateShortHash(catalogEntry.registryPath);
     const cacheStatus = catalogEntry.shardMetadata && catalogEntry.shardMetadata.length > 0
         ? await handleShardedModel(cacheKey, catalogEntry.shardMetadata)
-        : await handleSingleFileModel(catalogEntry.registryPath, catalogEntry.modelId, catalogEntry.expectedSize, catalogEntry.sha256Checksum);
-    const { cacheFiles, isCached, actualSize, cachedAt } = cacheStatus;
+        : catalogEntry.companionSet
+            ? await handleCompanionSetModel(catalogEntry.companionSet, catalogEntry.registryPath)
+            : await handleSingleFileModel(catalogEntry.registryPath, catalogEntry.expectedSize, catalogEntry.sha256Checksum);
+    const { cacheFiles, isCached, actualSize, cachedAt, primaryPath } = cacheStatus;
     const loadedModelIds = getAllModelIds();
+    const matchPath = primaryPath ?? cacheFiles[0]?.path;
     const loadedInstances = [];
     for (const id of loadedModelIds) {
         const entry = getModelEntry(id);
-        if (!entry?.local)
+        if (!entry || entry.isDelegated)
             continue;
         const matchesByName = entry.local.name && entry.local.name === name;
-        const matchesByPath = cacheFiles.length > 0 && entry.local.path === cacheFiles[0]?.path;
+        const matchesByPath = !!matchPath && entry.local.path === matchPath;
         if (matchesByName || matchesByPath) {
             const instance = {
                 registryId: id,
@@ -63,55 +65,100 @@ export async function handleGetModelInfo(request) {
     };
 }
 async function handleShardedModel(cacheKey, shardMetadata) {
+    const fileEntries = shardMetadata.map((s) => ({
+        filename: s.filename,
+        expectedSize: s.expectedSize,
+        sha256Checksum: s.sha256Checksum,
+    }));
+    const paths = shardMetadata.map((s) => getShardPath(cacheKey, s.filename));
+    return checkCacheStatus(fileEntries, paths);
+}
+async function handleCompanionSetModel(companionSet, primaryRegistryPath) {
+    const { setKey, primaryKey, files } = companionSet;
+    const baseCache = getModelsCacheDir();
+    const fileEntries = files.map((f) => ({
+        filename: f.targetName,
+        expectedSize: f.expectedSize,
+        sha256Checksum: f.sha256Checksum,
+        key: f.key,
+    }));
+    const canonicalPaths = files.map((f) => validateAndJoinPath(baseCache, "sets", setKey, f.targetName));
+    const canonicalResult = await checkCacheStatus(fileEntries, canonicalPaths, primaryKey);
+    if (canonicalResult.isCached)
+        return canonicalResult;
+    const isOnnxSet = files.some((f) => f.primary === true && f.targetName.endsWith(".onnx"));
+    if (isOnnxSet) {
+        const legacyCacheKey = generateShortHash(primaryRegistryPath);
+        const legacyPaths = files.map((f) => validateAndJoinPath(baseCache, "onnx", legacyCacheKey, f.targetName));
+        const legacyResult = await checkCacheStatus(fileEntries, legacyPaths, primaryKey);
+        if (legacyResult.isCached)
+            return legacyResult;
+    }
+    else {
+        // Legacy flat-cache compatibility for Bergamot-style companion sets.
+        // This is valid only for families whose runtime still works with explicit
+        // per-file absolute paths; it is not a generic rule for all companion sets.
+        const flatPaths = files.map((f) => getSingleFileCachePath(f.registryPath));
+        const flatResult = await checkCacheStatus(fileEntries, flatPaths, primaryKey);
+        if (flatResult.isCached)
+            return flatResult;
+    }
+    return canonicalResult;
+}
+async function checkCacheStatus(files, paths, primaryKey) {
     const cacheFiles = [];
-    let allShardsCached = true;
+    let allCached = true;
     let totalActualSize = 0;
     let latestCachedAt;
-    for (const shard of shardMetadata) {
-        const shardPath = getShardPath(cacheKey, shard.filename);
-        let shardIsCached = false;
-        let shardActualSize;
-        let shardCachedAt;
+    let primaryPath;
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        const filePath = paths[i];
+        let fileCached = false;
+        let fileActualSize;
+        let fileCachedAt;
         try {
-            const stats = await fsPromises.stat(shardPath);
-            const fileExists = stats.isFile();
-            if (fileExists) {
-                shardActualSize = stats.size;
-                shardCachedAt = stats.mtime;
-                shardIsCached = stats.size === shard.expectedSize;
-                if (shardIsCached) {
-                    totalActualSize += stats.size;
-                    if (!latestCachedAt || stats.mtime > latestCachedAt) {
-                        latestCachedAt = stats.mtime;
-                    }
-                }
-                else {
-                    allShardsCached = false;
-                }
-            }
-            else {
-                allShardsCached = false;
+            const stats = await fsPromises.stat(filePath);
+            if (stats.isFile()) {
+                fileActualSize = stats.size;
+                fileCachedAt = stats.mtime;
+                fileCached = stats.size === file.expectedSize;
             }
         }
         catch {
-            shardIsCached = false;
-            allShardsCached = false;
+            // file does not exist
+        }
+        if (primaryKey && file.key === primaryKey) {
+            primaryPath = filePath;
+        }
+        if (fileCached) {
+            totalActualSize += fileActualSize;
+            if (!latestCachedAt || fileCachedAt > latestCachedAt) {
+                latestCachedAt = fileCachedAt;
+            }
+        }
+        else {
+            allCached = false;
         }
         cacheFiles.push({
-            filename: shard.filename,
-            path: shardPath,
-            expectedSize: shard.expectedSize,
-            sha256Checksum: shard.sha256Checksum,
-            isCached: shardIsCached,
-            actualSize: shardActualSize,
-            cachedAt: shardCachedAt,
+            filename: file.filename,
+            path: filePath,
+            expectedSize: file.expectedSize,
+            sha256Checksum: file.sha256Checksum,
+            isCached: fileCached,
+            actualSize: fileActualSize,
+            cachedAt: fileCachedAt,
         });
     }
+    if (!primaryPath && cacheFiles.length > 0) {
+        primaryPath = cacheFiles[0].path;
+    }
     const result = {
         cacheFiles,
-        isCached: allShardsCached,
+        isCached: allCached,
+        primaryPath,
     };
-    if (allShardsCached) {
+    if (allCached) {
         result.actualSize = totalActualSize;
         if (latestCachedAt) {
             result.cachedAt = latestCachedAt;
@@ -119,46 +166,8 @@ async function handleShardedModel(cacheKey, shardMetadata) {
     }
     return result;
 }
-async function handleSingleFileModel(registryPath, modelId, expectedSize, sha256Checksum) {
-    const cacheDir = getConfiguredCacheDir();
-    // Use registryPath for hash to match download logic in registry.ts
-    const sourceHash = generateShortHash(registryPath);
-    const filePath = path.join(cacheDir, `${sourceHash}_${modelId}`);
-    let fileIsCached = false;
-    let fileActualSize;
-    let fileCachedAt;
-    try {
-        const stats = await fsPromises.stat(filePath);
-        const fileExists = stats.isFile();
-        if (fileExists) {
-            fileActualSize = stats.size;
-            fileCachedAt = stats.mtime;
-            fileIsCached = stats.size === expectedSize;
-        }
-    }
-    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;
+async function handleSingleFileModel(registryPath, expectedSize, sha256Checksum) {
+    const filename = registryPath.split("/").pop() || registryPath;
+    const filePath = getSingleFileCachePath(registryPath);
+    return checkCacheStatus([{ filename, expectedSize, sha256Checksum }], [filePath]);
 }

package/dist/server/rpc/handlers/heartbeat-delegated.js

@@ -8,9 +8,9 @@ export async function handleHeartbeatDelegated(request, options) {
     if (!delegate) {
         throw new DelegateConnectionFailedError("Delegated heartbeat handler called without delegate info");
     }
-    const { topic, providerPublicKey, timeout } = delegate;
+    const { providerPublicKey, timeout } = delegate;
     try {
-        const rpc = await getRPC(topic, providerPublicKey, { timeout });
+        const rpc = await getRPC(providerPublicKey, { timeout });
         const delegateOpts = {
             peerKey: providerPublicKey,
         };

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

@@ -13,7 +13,9 @@ import { handleRag } from "./rag";
 import { cancelHandler } from "./cancelHandler";
 import { handleDeleteCache } from "./delete-cache";
 import { handleTextToSpeech } from "./text-to-speech";
+import { handleTextToSpeechStream } from "./text-to-speech-stream";
 import { handleGetModelInfo } from "./get-model-info";
+import { handleGetLoadedModelInfo } from "./get-loaded-model-info";
 import { handleFinetune } from "./finetune";
 import { handleOCRStream } from "./ocr-stream";
 import { handleHeartbeat } from "./heartbeat";
@@ -22,6 +24,7 @@ import { handlePluginInvoke, handlePluginInvokeStream } from "./plugin-invoke";
 import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel } from "./registry";
 import { handleSuspend } from "./suspend";
 import { handleResume } from "./resume";
+import { handleState } from "./state";
 export declare const handlers: {
     heartbeat: typeof handleHeartbeat;
     completionStream: typeof handleCompletionStream;
@@ -39,7 +42,9 @@ export declare const handlers: {
     rag: typeof handleRag;
     cancel: typeof cancelHandler;
     textToSpeech: typeof handleTextToSpeech;
+    textToSpeechStream: typeof handleTextToSpeechStream;
     getModelInfo: typeof handleGetModelInfo;
+    getLoadedModelInfo: typeof handleGetLoadedModelInfo;
     finetune: typeof handleFinetune;
     ocrStream: typeof handleOCRStream;
     diffusionStream: typeof handleDiffusionStream;
@@ -50,5 +55,6 @@ export declare const handlers: {
     modelRegistryGetModel: typeof handleModelRegistryGetModel;
     suspend: typeof handleSuspend;
     resume: typeof handleResume;
+    state: typeof handleState;
 };
 //# sourceMappingURL=index.d.ts.map

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

@@ -13,7 +13,9 @@ import { handleRag } from "./rag.js";
 import { cancelHandler } from "./cancelHandler.js";
 import { handleDeleteCache } from "./delete-cache.js";
 import { handleTextToSpeech } from "./text-to-speech.js";
+import { handleTextToSpeechStream } from "./text-to-speech-stream.js";
 import { handleGetModelInfo } from "./get-model-info.js";
+import { handleGetLoadedModelInfo } from "./get-loaded-model-info.js";
 import { handleFinetune } from "./finetune.js";
 import { handleOCRStream } from "./ocr-stream.js";
 import { handleHeartbeat } from "./heartbeat.js";
@@ -22,6 +24,7 @@ import { handlePluginInvoke, handlePluginInvokeStream } from "./plugin-invoke.js
 import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel, } from "./registry.js";
 import { handleSuspend } from "./suspend.js";
 import { handleResume } from "./resume.js";
+import { handleState } from "./state.js";
 export const handlers = {
     heartbeat: handleHeartbeat,
     completionStream: handleCompletionStream,
@@ -39,7 +42,9 @@ export const handlers = {
     rag: handleRag,
     cancel: cancelHandler,
     textToSpeech: handleTextToSpeech,
+    textToSpeechStream: handleTextToSpeechStream,
     getModelInfo: handleGetModelInfo,
+    getLoadedModelInfo: handleGetLoadedModelInfo,
     finetune: handleFinetune,
     ocrStream: handleOCRStream,
     diffusionStream: handleDiffusionStream,
@@ -50,4 +55,5 @@ export const handlers = {
     modelRegistryGetModel: handleModelRegistryGetModel,
     suspend: handleSuspend,
     resume: handleResume,
+    state: handleState,
 };

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

@@ -1,14 +1,40 @@
-import { type DownloadEntry } from "../../../../schemas/index";
-export declare function getActiveDownload(key: string): DownloadEntry | undefined;
-export declare function registerDownload(key: string, entry: DownloadEntry): void;
-export declare function unregisterDownload(key: string): void;
+import type { ModelProgressUpdate } from "../../../../schemas/index";
+import { AbortController } from "bare-abort-controller";
+import type { DownloadHooks } from "./types";
+export interface Subscriber {
+    id: string;
+    onProgress?: ((progress: ModelProgressUpdate) => void) | undefined;
+    settled: boolean;
+    resolve: (path: string) => void;
+    reject: (error: unknown) => void;
+    promise: Promise<string>;
+}
+export interface Transfer {
+    downloadKey: string;
+    abortController: AbortController;
+    subscribers: Map<string, Subscriber>;
+    lastProgress?: ModelProgressUpdate | undefined;
+    downloadPromise?: Promise<string> | undefined;
+    clearCache: boolean;
+    cacheHit?: boolean;
+}
+export interface DownloadContext {
+    broadcastProgress: (progress: ModelProgressUpdate) => void;
+    signal: AbortSignal;
+    shouldClearCache: () => boolean;
+    setCacheHit: (cacheHit: boolean) => void;
+}
+export interface StartOrJoinResult {
+    promise: Promise<string>;
+    joined: boolean;
+    getCacheHit: () => boolean | undefined;
+}
+export declare function startOrJoinDownload(downloadKey: string, startDownload: (ctx: DownloadContext) => Promise<string>, onProgress?: (progress: ModelProgressUpdate) => void): StartOrJoinResult;
+export declare function cancelTransfer(downloadKey: string, clearCache?: boolean): void;
 export declare function createHyperdriveDownloadKey(hyperdriveKey: string, modelFileName: string): string;
 export declare function createHttpDownloadKey(url: string): string;
-export declare function createRegistryDownloadKey(registryPath: string): string;
-export declare function setClearCacheFlag(downloadKey: string, clearCache: boolean): void;
-export declare function shouldClearCache(downloadKey: string): boolean;
-export declare function clearClearCacheFlag(downloadKey: string): void;
-export declare function createCancelFunction(downloadKey: string, clearCache?: boolean): () => void;
+export declare function createRegistryDownloadKey(registrySource: string, registryPath: string): string;
+export declare function applyJoinedDownloadStats(result: StartOrJoinResult, hooks?: DownloadHooks): Promise<string>;
 export declare function cancelAllDownloads(): void;
 export declare function cleanupDownloads(): Promise<void>;
 //# sourceMappingURL=download-manager.d.ts.map