@qvac/sdk 0.9.2 → 0.10.1

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

@@ -1,16 +1,124 @@
-import {} from "../../../../schemas/index.js";
+import { AbortController } from "bare-abort-controller";
+import { DownloadCancelledError } from "../../../../utils/errors-server.js";
 import { getServerLogger } from "../../../../logging/index.js";
 const logger = getServerLogger();
-const activeDownloads = new Map();
-const clearCacheFlags = new Map();
-export function getActiveDownload(key) {
-    return activeDownloads.get(key);
+const activeTransfers = new Map();
+let nextSubscriberId = 0;
+function createSubscriber(onProgress) {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return {
+        id: String(nextSubscriberId++),
+        onProgress,
+        settled: false,
+        resolve,
+        reject,
+        promise,
+    };
+}
+function settleSubscriber(subscriber, result) {
+    if (subscriber.settled)
+        return;
+    subscriber.settled = true;
+    if (result instanceof Error) {
+        subscriber.reject(result);
+    }
+    else {
+        subscriber.resolve(result);
+    }
+}
+function deliverProgress(transfer, subscriber, progress) {
+    if (subscriber.settled || !subscriber.onProgress)
+        return;
+    try {
+        subscriber.onProgress(progress);
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        logger.warn("Progress callback threw; detaching subscriber", {
+            downloadKey: transfer.downloadKey,
+            subscriberId: subscriber.id,
+            error,
+        });
+        settleSubscriber(subscriber, error);
+        transfer.subscribers.delete(subscriber.id);
+    }
+}
+function broadcastTransferProgress(transfer, progress) {
+    transfer.lastProgress = progress;
+    for (const sub of Array.from(transfer.subscribers.values())) {
+        deliverProgress(transfer, sub, progress);
+    }
 }
-export function registerDownload(key, entry) {
-    activeDownloads.set(key, entry);
+export function startOrJoinDownload(downloadKey, startDownload, onProgress) {
+    const existing = activeTransfers.get(downloadKey);
+    if (existing && !existing.abortController.signal.aborted) {
+        logger.info(`📥 Reusing existing download for: ${downloadKey}`);
+        const subscriber = createSubscriber(onProgress);
+        existing.subscribers.set(subscriber.id, subscriber);
+        if (existing.lastProgress) {
+            deliverProgress(existing, subscriber, existing.lastProgress);
+        }
+        return {
+            promise: subscriber.promise,
+            joined: true,
+            getCacheHit: () => existing.cacheHit,
+        };
+    }
+    const abortController = new AbortController();
+    const transfer = {
+        downloadKey,
+        abortController,
+        subscribers: new Map(),
+        clearCache: false,
+    };
+    const initialSubscriber = createSubscriber(onProgress);
+    transfer.subscribers.set(initialSubscriber.id, initialSubscriber);
+    activeTransfers.set(downloadKey, transfer);
+    const downloadPromise = startDownload({
+        broadcastProgress: (progress) => {
+            broadcastTransferProgress(transfer, progress);
+        },
+        signal: abortController.signal,
+        shouldClearCache: () => transfer.clearCache,
+        setCacheHit: (cacheHit) => {
+            transfer.cacheHit = cacheHit;
+        },
+    });
+    transfer.downloadPromise = downloadPromise;
+    downloadPromise.then((path) => {
+        for (const sub of transfer.subscribers.values()) {
+            settleSubscriber(sub, path);
+        }
+    }, (error) => {
+        const rejection = error instanceof Error ? error : new Error(String(error));
+        for (const sub of transfer.subscribers.values()) {
+            settleSubscriber(sub, rejection);
+        }
+    }).finally(() => {
+        if (activeTransfers.get(downloadKey) === transfer) {
+            activeTransfers.delete(downloadKey);
+        }
+    });
+    return {
+        promise: initialSubscriber.promise,
+        joined: false,
+        getCacheHit: () => transfer.cacheHit,
+    };
 }
-export function unregisterDownload(key) {
-    activeDownloads.delete(key);
+export function cancelTransfer(downloadKey, clearCache = false) {
+    const transfer = activeTransfers.get(downloadKey);
+    if (!transfer)
+        return;
+    transfer.clearCache = clearCache;
+    transfer.abortController.abort();
+    for (const sub of transfer.subscribers.values()) {
+        settleSubscriber(sub, new DownloadCancelledError());
+    }
 }
 export function createHyperdriveDownloadKey(hyperdriveKey, modelFileName) {
     return `${hyperdriveKey}:${modelFileName}`;
@@ -18,38 +126,32 @@ export function createHyperdriveDownloadKey(hyperdriveKey, modelFileName) {
 export function createHttpDownloadKey(url) {
     return `http:${url}`;
 }
-export function createRegistryDownloadKey(registryPath) {
-    return `registry:${registryPath}`;
-}
-export function setClearCacheFlag(downloadKey, clearCache) {
-    if (clearCache) {
-        clearCacheFlags.set(downloadKey, true);
-    }
-    else {
-        clearCacheFlags.delete(downloadKey);
-    }
-}
-export function shouldClearCache(downloadKey) {
-    return clearCacheFlags.get(downloadKey) ?? false;
-}
-export function clearClearCacheFlag(downloadKey) {
-    clearCacheFlags.delete(downloadKey);
+export function createRegistryDownloadKey(registrySource, registryPath) {
+    return `registry:${registrySource}:${registryPath}`;
 }
-export function createCancelFunction(downloadKey, clearCache = false) {
-    return () => {
-        const entry = getActiveDownload(downloadKey);
-        if (!entry) {
-            return;
+export function applyJoinedDownloadStats(result, hooks) {
+    if (!result.joined)
+        return result.promise;
+    return result.promise.then((path) => {
+        const cacheHit = result.getCacheHit();
+        if (cacheHit === true) {
+            hooks?.markCacheHit?.();
         }
-        // Set flag for the download handlers to check
-        setClearCacheFlag(downloadKey, clearCache);
-        entry.abortController.abort();
-        unregisterDownload(downloadKey);
-    };
+        else if (cacheHit === false) {
+            hooks?.markCacheMiss?.();
+            hooks?.markSharedTransfer?.();
+        }
+        else {
+            hooks?.markSharedTransfer?.();
+        }
+        return path;
+    });
 }
 export function cancelAllDownloads() {
-    logger.info(`🧹 Cancelling ${activeDownloads.size} active downloads`);
-    Array.from(activeDownloads.keys()).forEach((key) => createCancelFunction(key)());
+    logger.info(`🧹 Cancelling ${activeTransfers.size} active downloads`);
+    for (const key of Array.from(activeTransfers.keys())) {
+        cancelTransfer(key);
+    }
 }
 let isCleaningUp = false;
 export async function cleanupDownloads() {
@@ -57,7 +159,9 @@ export async function cleanupDownloads() {
         return;
     isCleaningUp = true;
     try {
-        const downloadPromises = Array.from(activeDownloads.values()).map((entry) => entry.promise.catch(() => { }));
+        const downloadPromises = Array.from(activeTransfers.values())
+            .filter((t) => t.downloadPromise !== undefined)
+            .map((t) => t.downloadPromise.catch(() => { }));
         cancelAllDownloads();
         if (downloadPromises.length > 0) {
             await Promise.allSettled(downloadPromises);

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

@@ -1,6 +1,7 @@
 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>;
+import type { DownloadStats, DownloadResult, DownloadHooks, ResolveResult } from "./types";
+export declare function downloadModelFromHttpWithStats(url: string, progressCallback?: (progress: ModelProgressUpdate) => void, downloadHooks?: DownloadHooks): Promise<DownloadResult>;
+export declare function downloadModelFromRegistryWithStats(registryPath: string, registrySource: string, progressCallback?: (progress: ModelProgressUpdate) => void, expectedChecksum?: string, downloadHooks?: DownloadHooks): Promise<DownloadResult>;
+export declare function downloadModelFromHyperdriveWithStats(hyperdriveKey: string, modelFileName: string, seed?: boolean, progressCallback?: (progress: ModelProgressUpdate) => void, downloadHooks?: DownloadHooks): Promise<DownloadResult>;
+export declare function mergeDownloadStats(results: ResolveResult[]): DownloadStats | undefined;
 //# sourceMappingURL=download-stats.d.ts.map

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

@@ -7,10 +7,11 @@ function createStatsCollector() {
         maxBytesDownloaded: 0,
         startTimeMs: nowMs(),
         cacheHit: undefined,
+        sharedTransfer: false,
         checksumValidationTimeMsTotal: 0,
     };
 }
-function createHooks(collector) {
+function createStatsHooks(collector) {
     return {
         markCacheHit: () => {
             if (collector.cacheHit === undefined) {
@@ -21,6 +22,9 @@ function createHooks(collector) {
         markCacheMiss: () => {
             collector.cacheHit = false;
         },
+        markSharedTransfer: () => {
+            collector.sharedTransfer = true;
+        },
         addChecksumValidationTimeMs: (durationMs) => {
             collector.checksumValidationTimeMsTotal += durationMs;
         },
@@ -30,7 +34,7 @@ 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 ??
+            const downloaded = progress.fileSetInfo?.overallDownloaded ??
                 progress.shardInfo?.overallDownloaded ??
                 progress.downloaded ??
                 0;
@@ -43,6 +47,9 @@ function computeStats(collector) {
     const downloadTimeMs = nowMs() - collector.startTimeMs;
     const totalBytesDownloaded = collector.maxBytesDownloaded;
     const stats = {};
+    if (collector.sharedTransfer) {
+        stats.sharedTransfer = true;
+    }
     if (collector.cacheHit !== undefined) {
         stats.cacheHit = collector.cacheHit;
     }
@@ -52,6 +59,12 @@ function computeStats(collector) {
     if (collector.cacheHit === true) {
         return Object.keys(stats).length > 0 ? stats : undefined;
     }
+    if (collector.sharedTransfer) {
+        if (downloadTimeMs > 0) {
+            stats.downloadTimeMs = downloadTimeMs;
+        }
+        return Object.keys(stats).length > 0 ? stats : undefined;
+    }
     if (totalBytesDownloaded > 0) {
         stats.downloadTimeMs = downloadTimeMs;
         stats.totalBytesDownloaded = totalBytesDownloaded;
@@ -61,27 +74,55 @@ function computeStats(collector) {
     }
     return Object.keys(stats).length > 0 ? stats : undefined;
 }
-export async function downloadModelFromHttpWithStats(url, progressCallback) {
+export async function downloadModelFromHttpWithStats(url, progressCallback, downloadHooks) {
     const collector = createStatsCollector();
-    const hooks = createHooks(collector);
+    const hooks = { ...downloadHooks, ...createStatsHooks(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) {
+export async function downloadModelFromRegistryWithStats(registryPath, registrySource, progressCallback, expectedChecksum, downloadHooks) {
     const collector = createStatsCollector();
-    const hooks = createHooks(collector);
+    const hooks = { ...downloadHooks, ...createStatsHooks(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) {
+export async function downloadModelFromHyperdriveWithStats(hyperdriveKey, modelFileName, seed, progressCallback, downloadHooks) {
     const collector = createStatsCollector();
-    const hooks = createHooks(collector);
+    const hooks = { ...downloadHooks, ...createStatsHooks(collector) };
     const wrappedCallback = wrapProgressCallback(collector, progressCallback);
     const path = await downloadModelFromHyperdrive(hyperdriveKey, modelFileName, seed, wrappedCallback, hooks);
     const stats = computeStats(collector);
     return stats ? { path, stats } : { path };
 }
+export function mergeDownloadStats(results) {
+    const stats = results
+        .map((r) => r.downloadStats)
+        .filter((s) => s !== undefined);
+    if (stats.length === 0)
+        return undefined;
+    const downloadTimeMs = Math.max(...stats.map((s) => s.downloadTimeMs ?? 0));
+    const totalBytesDownloaded = stats.reduce((sum, s) => sum + (s.totalBytesDownloaded ?? 0), 0);
+    const checksumValidationTimeMs = stats.reduce((sum, s) => sum + (s.checksumValidationTimeMs ?? 0), 0);
+    const cacheHitValues = stats
+        .map((s) => s.cacheHit)
+        .filter((v) => v !== undefined);
+    const merged = {};
+    if (downloadTimeMs > 0)
+        merged.downloadTimeMs = downloadTimeMs;
+    if (totalBytesDownloaded > 0)
+        merged.totalBytesDownloaded = totalBytesDownloaded;
+    if (downloadTimeMs > 0 && totalBytesDownloaded > 0) {
+        merged.downloadSpeedBps = (totalBytesDownloaded * 1000) / downloadTimeMs;
+    }
+    if (checksumValidationTimeMs > 0)
+        merged.checksumValidationTimeMs = checksumValidationTimeMs;
+    if (cacheHitValues.length > 0)
+        merged.cacheHit = cacheHitValues.every(Boolean);
+    if (stats.some((s) => s.sharedTransfer))
+        merged.sharedTransfer = true;
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}

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

@@ -1,9 +1,10 @@
 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 { createResolveSession } from "./resolve-session.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 { buildDownloadProfilingFields } from "./types.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";
@@ -34,37 +35,39 @@ export async function handleLoadModel(request, progressCallback) {
         }
         resolvedModelConfig = parseResult.data;
         const totalLoadStart = profilingEnabled ? nowMs() : 0;
-        let resolveResult;
+        const session = createResolveSession({
+            progressCallback,
+            seed,
+            profilingEnabled,
+        });
+        const primaryResolve = session.resolvePrimaryModelPath(modelSrc);
         let resolvedModelPath;
-        if (profilingEnabled) {
-            resolveResult = await resolveModelPathWithStats(modelSrc, progressCallback, seed);
-            resolvedModelPath = resolveResult.path;
+        let pluginResolveResult;
+        try {
+            const pluginResolve = plugin.resolveConfig
+                ? Promise.resolve().then(() => plugin.resolveConfig(resolvedModelConfig, session.createResolveContext(modelSrc, canonicalModelType, modelName)))
+                : undefined;
+            [resolvedModelPath, pluginResolveResult] = pluginResolve
+                ? await Promise.all([primaryResolve, pluginResolve])
+                : [await primaryResolve, undefined];
         }
-        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;
-            }
+        catch (error) {
+            session.cancelAll();
+            throw error;
         }
         const configStr = canonicalConfigString(request.modelConfig);
         const modelHashInput = `${request.modelType}:${modelSrc}:${configStr}`;
         const modelId = generateShortHash(modelHashInput);
+        let pluginArtifacts = {};
+        if (pluginResolveResult) {
+            resolvedModelConfig = pluginResolveResult.config;
+            if (pluginResolveResult.artifacts) {
+                pluginArtifacts = pluginResolveResult.artifacts;
+            }
+        }
         if ("modelPath" in pluginArtifacts) {
-            logger.warn("Plugin returned 'modelPath' artifact which was overridden by core");
+            throw new ModelLoadFailedError("Plugin returned reserved key \"modelPath\" in artifacts; primary model resolution is core-owned");
         }
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { modelPath: _, ...artifacts } = pluginArtifacts;
         if (!resolvedModelPath) {
             throw new ModelLoadFailedError("modelPath resolution failed");
         }
@@ -76,7 +79,7 @@ export async function handleLoadModel(request, progressCallback) {
                 modelType: canonicalModelType,
                 modelConfig: resolvedModelConfig,
             },
-            artifacts: Object.keys(artifacts).length > 0 ? artifacts : undefined,
+            artifacts: Object.keys(pluginArtifacts).length > 0 ? pluginArtifacts : undefined,
             modelName,
         }, profilingEnabled ? { collectTiming: true } : undefined);
         const response = {
@@ -87,38 +90,16 @@ export async function handleLoadModel(request, progressCallback) {
         if (profilingEnabled) {
             const totalLoadTimeMs = nowMs() - totalLoadStart;
             const profileId = profilingMeta?.id ?? generateProfileId();
-            const gauges = {
-                totalLoadTime: totalLoadTimeMs,
-            };
+            const resolveResult = session.getAggregateResult();
+            const { gauges, tags } = buildDownloadProfilingFields(resolveResult?.downloadStats, resolveResult?.sourceType);
+            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",

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

@@ -1,4 +1,4 @@
 import type { ModelProgressUpdate } from "../../../../schemas/index";
-import type { DownloadMetricsHooks } from "./types";
-export declare function downloadModelFromHttp(url: string, progressCallback?: (progress: ModelProgressUpdate) => void, hooks?: DownloadMetricsHooks): Promise<string>;
+import type { DownloadHooks } from "./types";
+export declare function downloadModelFromHttp(url: string, progressCallback?: (progress: ModelProgressUpdate) => void, hooks?: DownloadHooks): Promise<string>;
 //# sourceMappingURL=http.d.ts.map