@qvac/sdk 0.8.1 → 1.0.0

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

@@ -1,164 +0,0 @@
-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 { ModelNotFoundError } from "../../../utils/errors-server.js";
-export async function handleGetModelInfo(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 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;
-    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,
-        registryPath: catalogEntry.registryPath,
-        registrySource: catalogEntry.registrySource,
-        blobCoreKey: catalogEntry.blobCoreKey,
-        blobBlockOffset: catalogEntry.blobBlockOffset,
-        blobBlockLength: catalogEntry.blobBlockLength,
-        blobByteOffset: catalogEntry.blobByteOffset,
-        engine: catalogEntry.engine,
-        quantization: catalogEntry.quantization,
-        params: catalogEntry.params,
-        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(cacheKey, shardMetadata) {
-    const cacheFiles = [];
-    let allShardsCached = true;
-    let totalActualSize = 0;
-    let latestCachedAt;
-    for (const shard of shardMetadata) {
-        const shardPath = getShardPath(cacheKey, shard.filename);
-        let shardIsCached = false;
-        let shardActualSize;
-        let shardCachedAt;
-        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;
-            }
-        }
-        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(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;
-}

package/dist/server/rpc/handlers/heartbeat-delegated.d.ts

@@ -1,4 +0,0 @@
-import type { HeartbeatRequest, HeartbeatResponse } from "../../../schemas/index";
-import type { DelegatedHandlerOptions } from "../profiling/index";
-export declare function handleHeartbeatDelegated(request: HeartbeatRequest, options?: DelegatedHandlerOptions): Promise<HeartbeatResponse>;
-//# sourceMappingURL=heartbeat-delegated.d.ts.map

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

@@ -1,32 +0,0 @@
-import { getServerLogger } from "../../../logging/index.js";
-import { getRPC } from "../../bare/delegate-rpc-client.js";
-import { send } from "../delegate-transport.js";
-import { DelegateConnectionFailedError } from "../../../utils/errors-server.js";
-const logger = getServerLogger();
-export async function handleHeartbeatDelegated(request, options) {
-    const { delegate } = request;
-    if (!delegate) {
-        throw new DelegateConnectionFailedError("Delegated heartbeat handler called without delegate info");
-    }
-    const { topic, providerPublicKey, timeout } = delegate;
-    try {
-        const rpc = await getRPC(topic, providerPublicKey, { timeout });
-        const delegateOpts = {
-            peerKey: providerPublicKey,
-        };
-        if (timeout !== undefined) {
-            delegateOpts.timeout = timeout;
-        }
-        if (options?.profilingMeta) {
-            delegateOpts.profilingMeta = options.profilingMeta;
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { delegate: _delegate, ...providerRequest } = request;
-        const response = await send(providerRequest, rpc, delegateOpts);
-        return response;
-    }
-    catch (error) {
-        logger.error("Error during delegated heartbeat:", error);
-        throw error;
-    }
-}

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

@@ -1,3 +0,0 @@
-import type { HeartbeatResponse } from "../../../schemas/index";
-export declare function handleHeartbeat(): HeartbeatResponse;
-//# sourceMappingURL=heartbeat.d.ts.map

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

@@ -1,3 +0,0 @@
-export function handleHeartbeat() {
-    return { type: "heartbeat", number: Math.random() * 100 };
-}

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

@@ -1,6 +0,0 @@
-import type { ModelProgressUpdate } from "../../../../schemas/index";
-import type { DownloadResult } from "./types";
-export declare function downloadModelFromHttpWithStats(url: string, progressCallback?: (progress: ModelProgressUpdate) => void): Promise<DownloadResult>;
-export declare function downloadModelFromRegistryWithStats(registryPath: string, registrySource: string, progressCallback?: (progress: ModelProgressUpdate) => void, expectedChecksum?: string): Promise<DownloadResult>;
-export declare function downloadModelFromHyperdriveWithStats(hyperdriveKey: string, modelFileName: string, seed?: boolean, progressCallback?: (progress: ModelProgressUpdate) => void): Promise<DownloadResult>;
-//# sourceMappingURL=download-stats.d.ts.map

package/dist/server/rpc/handlers/load-model/download-stats.js

@@ -1,87 +0,0 @@
-import { downloadModelFromHttp } from "./http.js";
-import { downloadModelFromRegistry } from "./registry.js";
-import { downloadModelFromHyperdrive } from "./hyperdrive.js";
-import { nowMs } from "../../../../profiling/index.js";
-function createStatsCollector() {
-    return {
-        maxBytesDownloaded: 0,
-        startTimeMs: nowMs(),
-        cacheHit: undefined,
-        checksumValidationTimeMsTotal: 0,
-    };
-}
-function createHooks(collector) {
-    return {
-        markCacheHit: () => {
-            if (collector.cacheHit === undefined) {
-                collector.cacheHit = true;
-                collector.maxBytesDownloaded = 0;
-            }
-        },
-        markCacheMiss: () => {
-            collector.cacheHit = false;
-        },
-        addChecksumValidationTimeMs: (durationMs) => {
-            collector.checksumValidationTimeMsTotal += durationMs;
-        },
-    };
-}
-function wrapProgressCallback(collector, originalCallback) {
-    return (progress) => {
-        // Don't track bytes for cache hits (they're not real network transfer)
-        if (collector.cacheHit !== true) {
-            const downloaded = progress.onnxInfo?.overallDownloaded ??
-                progress.shardInfo?.overallDownloaded ??
-                progress.downloaded ??
-                0;
-            collector.maxBytesDownloaded = Math.max(collector.maxBytesDownloaded, downloaded);
-        }
-        originalCallback?.(progress);
-    };
-}
-function computeStats(collector) {
-    const downloadTimeMs = nowMs() - collector.startTimeMs;
-    const totalBytesDownloaded = collector.maxBytesDownloaded;
-    const stats = {};
-    if (collector.cacheHit !== undefined) {
-        stats.cacheHit = collector.cacheHit;
-    }
-    if (collector.checksumValidationTimeMsTotal > 0) {
-        stats.checksumValidationTimeMs = collector.checksumValidationTimeMsTotal;
-    }
-    if (collector.cacheHit === true) {
-        return Object.keys(stats).length > 0 ? stats : undefined;
-    }
-    if (totalBytesDownloaded > 0) {
-        stats.downloadTimeMs = downloadTimeMs;
-        stats.totalBytesDownloaded = totalBytesDownloaded;
-        if (downloadTimeMs > 0) {
-            stats.downloadSpeedBps = (totalBytesDownloaded * 1000) / downloadTimeMs;
-        }
-    }
-    return Object.keys(stats).length > 0 ? stats : undefined;
-}
-export async function downloadModelFromHttpWithStats(url, progressCallback) {
-    const collector = createStatsCollector();
-    const hooks = createHooks(collector);
-    const wrappedCallback = wrapProgressCallback(collector, progressCallback);
-    const path = await downloadModelFromHttp(url, wrappedCallback, hooks);
-    const stats = computeStats(collector);
-    return stats ? { path, stats } : { path };
-}
-export async function downloadModelFromRegistryWithStats(registryPath, registrySource, progressCallback, expectedChecksum) {
-    const collector = createStatsCollector();
-    const hooks = createHooks(collector);
-    const wrappedCallback = wrapProgressCallback(collector, progressCallback);
-    const path = await downloadModelFromRegistry(registryPath, registrySource, wrappedCallback, expectedChecksum, hooks);
-    const stats = computeStats(collector);
-    return stats ? { path, stats } : { path };
-}
-export async function downloadModelFromHyperdriveWithStats(hyperdriveKey, modelFileName, seed, progressCallback) {
-    const collector = createStatsCollector();
-    const hooks = createHooks(collector);
-    const wrappedCallback = wrapProgressCallback(collector, progressCallback);
-    const path = await downloadModelFromHyperdrive(hyperdriveKey, modelFileName, seed, wrappedCallback, hooks);
-    const stats = computeStats(collector);
-    return stats ? { path, stats } : { path };
-}

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

@@ -1,187 +0,0 @@
-import { normalizeModelType, PROFILING_KEY, OPERATION_EVENT_KEY, } from "../../../../schemas/index.js";
-import { loadModel } from "../../../bare/ops/load-model.js";
-import { resolveModelPath, resolveModelPathWithStats, } from "./resolve.js";
-import { nowMs, generateProfileId } from "../../../../profiling/clock.js";
-import { getModelEntry, updateModelConfig, } from "../../../bare/registry/model-registry.js";
-import { generateShortHash, canonicalConfigString, transformConfigForReload, } from "../../../utils/index.js";
-import { ConfigReloadNotSupportedError, ModelTypeMismatchError, ModelIsDelegatedError, ModelNotFoundError, ModelLoadFailedError, PluginLoadConfigValidationFailedError, PluginNotFoundError, } from "../../../../utils/errors-server.js";
-import { getServerLogger } from "../../../../logging/index.js";
-import { getPlugin } from "../../../plugins/index.js";
-const logger = getServerLogger();
-// ---------------------------------------------------------------------------
-// Handler
-// ---------------------------------------------------------------------------
-export async function handleLoadModel(request, progressCallback) {
-    if (isReloadConfigRequest(request)) {
-        return handleConfigReload(request);
-    }
-    const { modelSrc, modelName, seed } = request;
-    const canonicalModelType = normalizeModelType(request.modelType);
-    const profilingMeta = request[PROFILING_KEY];
-    const profilingEnabled = profilingMeta?.enabled !== false && !!profilingMeta;
-    try {
-        const plugin = getPlugin(canonicalModelType);
-        if (!plugin) {
-            throw new PluginNotFoundError(canonicalModelType);
-        }
-        let resolvedModelConfig = (request.modelConfig ?? {});
-        const parseResult = plugin.loadConfigSchema.safeParse(resolvedModelConfig);
-        if (!parseResult.success) {
-            const details = parseResult.error.issues
-                .map((i) => `${String(i.path.join("."))}: ${i.message}`)
-                .join(", ");
-            throw new PluginLoadConfigValidationFailedError(canonicalModelType, details);
-        }
-        resolvedModelConfig = parseResult.data;
-        const totalLoadStart = profilingEnabled ? nowMs() : 0;
-        let resolveResult;
-        let resolvedModelPath;
-        if (profilingEnabled) {
-            resolveResult = await resolveModelPathWithStats(modelSrc, progressCallback, seed);
-            resolvedModelPath = resolveResult.path;
-        }
-        else {
-            resolvedModelPath = await resolveModelPath(modelSrc, progressCallback, seed);
-        }
-        let pluginArtifacts = {};
-        if (plugin.resolveConfig) {
-            const ctx = {
-                resolveModelPath: (src) => resolveModelPath(src, progressCallback, seed),
-                modelSrc,
-                modelType: canonicalModelType,
-                ...(modelName !== undefined && { modelName }),
-            };
-            const result = await plugin.resolveConfig(resolvedModelConfig, ctx);
-            resolvedModelConfig = result.config;
-            if (result.artifacts) {
-                pluginArtifacts = result.artifacts;
-            }
-        }
-        const configStr = canonicalConfigString(request.modelConfig);
-        const modelHashInput = `${request.modelType}:${modelSrc}:${configStr}`;
-        const modelId = generateShortHash(modelHashInput);
-        if ("modelPath" in pluginArtifacts) {
-            logger.warn("Plugin returned 'modelPath' artifact which was overridden by core");
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { modelPath: _, ...artifacts } = pluginArtifacts;
-        if (!resolvedModelPath) {
-            throw new ModelLoadFailedError("modelPath resolution failed");
-        }
-        const loadResult = await loadModel({
-            modelId,
-            modelPath: resolvedModelPath,
-            options: {
-                ...request,
-                modelType: canonicalModelType,
-                modelConfig: resolvedModelConfig,
-            },
-            artifacts: Object.keys(artifacts).length > 0 ? artifacts : undefined,
-            modelName,
-        }, profilingEnabled ? { collectTiming: true } : undefined);
-        const response = {
-            type: "loadModel",
-            success: true,
-            modelId,
-        };
-        if (profilingEnabled) {
-            const totalLoadTimeMs = nowMs() - totalLoadStart;
-            const profileId = profilingMeta?.id ?? generateProfileId();
-            const gauges = {
-                totalLoadTime: totalLoadTimeMs,
-            };
-            if (loadResult.timing?.modelInitializationTimeMs !== undefined) {
-                gauges["modelInitializationTime"] =
-                    loadResult.timing.modelInitializationTimeMs;
-            }
-            if (resolveResult?.downloadStats) {
-                const ds = resolveResult.downloadStats;
-                if (ds.downloadTimeMs !== undefined) {
-                    gauges["downloadTime"] = ds.downloadTimeMs;
-                }
-                if (ds.totalBytesDownloaded !== undefined) {
-                    gauges["totalBytesDownloaded"] = ds.totalBytesDownloaded;
-                }
-                if (ds.downloadSpeedBps !== undefined) {
-                    gauges["downloadSpeedBps"] = ds.downloadSpeedBps;
-                }
-                if (ds.checksumValidationTimeMs !== undefined) {
-                    gauges["checksumValidationTime"] = ds.checksumValidationTimeMs;
-                }
-            }
-            const tags = {};
-            if (canonicalModelType) {
-                tags["modelType"] = canonicalModelType;
-            }
-            if (resolveResult?.sourceType) {
-                tags["sourceType"] = resolveResult.sourceType;
-            }
-            if (resolveResult?.downloadStats?.cacheHit !== undefined) {
-                tags["cacheHit"] = resolveResult.downloadStats.cacheHit ? "true" : "false";
-            }
-            const operationEvent = {
-                op: "loadModel",
-                kind: "handler",
-                ms: totalLoadTimeMs,
-                profileId,
-                gauges: Object.keys(gauges).length > 0 ? gauges : undefined,
-                tags: Object.keys(tags).length > 0 ? tags : undefined,
-            };
-            response[OPERATION_EVENT_KEY] = operationEvent;
-        }
-        return response;
-    }
-    catch (error) {
-        logger.error("Error loading model:", error);
-        return {
-            type: "loadModel",
-            success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
-        };
-    }
-}
-async function handleConfigReload(request) {
-    const { modelId, modelType, modelConfig } = request;
-    try {
-        const entry = getModelEntry(modelId);
-        if (!entry) {
-            throw new ModelNotFoundError(modelId);
-        }
-        if (entry.isDelegated) {
-            throw new ModelIsDelegatedError(modelId);
-        }
-        const storedModelType = entry.local.modelType;
-        const normalizedRequestType = normalizeModelType(modelType);
-        if (storedModelType !== normalizedRequestType) {
-            throw new ModelTypeMismatchError(storedModelType, normalizedRequestType);
-        }
-        const model = entry.local.model;
-        const currentConfig = entry.local.config;
-        if (typeof model.reload !== "function") {
-            throw new ConfigReloadNotSupportedError(modelId);
-        }
-        const mergedConfig = {
-            ...currentConfig,
-            ...modelConfig,
-        };
-        const reloadConfig = transformConfigForReload(storedModelType, mergedConfig);
-        await model.reload(reloadConfig);
-        updateModelConfig(modelId, mergedConfig);
-        return {
-            type: "loadModel",
-            success: true,
-            modelId,
-        };
-    }
-    catch (error) {
-        logger.error("Error reloading config:", error);
-        return {
-            type: "loadModel",
-            success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
-        };
-    }
-}
-function isReloadConfigRequest(request) {
-    return "modelId" in request && !("modelSrc" in request);
-}

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

@@ -1,11 +0,0 @@
-import type { ModelProgressUpdate } from "../../../../schemas/index";
-import type { DownloadMetricsHooks } from "./types";
-/**
- * Download a model from the QVAC Registry.
- *
- * For known models (present in models.ts), uses direct blob download which
- * skips the registry metadata sync entirely. Falls back to metadata-based
- * download for unknown models.
- */
-export declare function downloadModelFromRegistry(registryPath: string, registrySource: string, progressCallback?: (progress: ModelProgressUpdate) => void, expectedChecksum?: string, hooks?: DownloadMetricsHooks): Promise<string>;
-//# sourceMappingURL=registry.d.ts.map