@qvac/sdk 0.8.1 → 1.0.0

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

@@ -1,77 +1,53 @@
 import fs, { promises as fsPromises } from "bare-fs";
-import path from "bare-path";
 import { Readable } from "bare-stream";
 import fetch from "bare-fetch";
 import { AbortController } from "bare-abort-controller";
-import { withTimeout } from "../../../../utils/withTimeout.js";
-import { getModelsCacheDir, getShardedModelCacheDir, generateShortHash, detectShardedModel, parsePatternBasedShardUrl, extractTensorsFromShards, calculatePercentage, isArchiveUrl, sanitizePathComponent, extractAndValidateShardedArchive, validateShardedModelCache, checkAllShardsExist, generateShardFilenames, hasValidGGUFHeader, } from "../../../utils/index.js";
-import { getSDKConfig } from "../../../bare/registry/config-registry.js";
+import { getModelsCacheDir, generateShortHash } from "../../../utils/index.js";
 import { getActiveDownload, registerDownload, unregisterDownload, createHttpDownloadKey, shouldClearCache, clearClearCacheFlag, } from "./download-manager.js";
-import { DownloadCancelledError, HTTPError, NoResponseBodyError, PartialDownloadOfflineError, ResponseBodyNotReadableError, } from "../../../../utils/errors-server.js";
-import { getServerLogger } from "../../../../logging/index.js";
-const logger = getServerLogger();
-const DEFAULT_CONCURRENCY = 3;
-const DEFAULT_HTTP_CONNECTION_TIMEOUT_MS = 10_000;
 function extractFilenameFromUrl(url) {
     // Parse URL to get the filename from the path
     const urlParts = url.split("/");
     const filename = urlParts[urlParts.length - 1] || "model.gguf";
     // Remove query parameters if present
     const cleanFilename = filename.split("?")[0] || "model.gguf";
-    // Sanitize to prevent path traversal via crafted URLs
-    return sanitizePathComponent(cleanFilename);
+    return cleanFilename;
 }
 async function validateCachedFile(modelPath, url, signal) {
     try {
         await fsPromises.access(modelPath);
         const localStats = await fsPromises.stat(modelPath);
         const localSize = localStats.size;
-        const config = getSDKConfig();
-        const connectionTimeout = config.httpConnectionTimeoutMs ?? DEFAULT_HTTP_CONNECTION_TIMEOUT_MS;
+        // Get expected size from HEAD request
         let expectedSize = 0;
         try {
-            const response = await withTimeout(fetch(url, {
+            const response = await fetch(url, {
                 method: "HEAD",
                 ...(signal && { signal }),
-            }), connectionTimeout);
+            });
             expectedSize = parseInt(response.headers.get("content-length") || "0");
         }
-        catch (headError) {
-            logger.warn(`⚠️ HEAD request failed: ${headError instanceof Error ? headError.message : String(headError)}`);
-            logger.info(`📴 Falling back to GGUF header validation...`);
-            const hasValidHeader = await hasValidGGUFHeader(modelPath);
-            if (hasValidHeader) {
-                logger.info(`✅ Offline - GGUF header valid, using cached file: ${modelPath}`);
-                return modelPath;
-            }
-            if (localSize > 0) {
-                logger.error(`❌ Offline with partial download (${localSize} bytes). Cannot resume without network.`);
-                throw new PartialDownloadOfflineError(url, localSize);
-            }
-            logger.warn(`⚠️ Offline and GGUF validation failed - file may be incomplete`);
-            return null;
+        catch (error) {
+            console.log(`⚠️ Could not get expected file size from HEAD request: ${String(error)}`);
+            console.log(`✅ Using cached HTTP model: ${modelPath}`);
+            return modelPath;
         }
-        if (localSize !== expectedSize) {
-            logger.info(`📥 Cached file size mismatch. Expected: ${expectedSize}, Found: ${localSize}. Re-downloading...`);
+        if (expectedSize > 0 && localSize !== expectedSize) {
+            console.log(`📥 Cached file size mismatch. Expected: ${expectedSize}, Found: ${localSize}. Re-downloading...`);
             return null;
         }
-        logger.info(`✅ Using cached HTTP model: ${modelPath}`);
+        console.log(`✅ Using cached HTTP model: ${modelPath}`);
         return modelPath;
     }
-    catch (error) {
-        // Re-throw PartialDownloadOfflineError
-        if (error instanceof PartialDownloadOfflineError) {
-            throw error;
-        }
-        // File doesn't exist or other access error
+    catch {
+        // File doesn't exist
         return null;
     }
 }
 async function performHttpDownload(url, modelPath, downloadKey, progressCallback, signal) {
     if (signal?.aborted) {
-        throw new DownloadCancelledError();
+        throw new Error("Download cancelled");
     }
-    logger.info(`📥 Downloading model from HTTP: ${url}`);
+    console.log(`📥 Downloading model from HTTP: ${url}`);
     // Check if file exists for resuming
     let startOffset = 0;
     let downloadedBytes = 0;
@@ -79,10 +55,10 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
         const existingStats = await fsPromises.stat(modelPath);
         startOffset = existingStats.size;
         downloadedBytes = startOffset;
-        logger.info(`📥 Resuming download from byte ${startOffset}`);
+        console.log(`📥 Resuming download from byte ${startOffset}`);
     }
     catch {
-        logger.info(`📥 Starting fresh download`);
+        console.log(`📥 Starting fresh download`);
     }
     // Prepare headers for resume if needed
     const headers = {
@@ -91,62 +67,41 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
     if (startOffset > 0) {
         headers["Range"] = `bytes=${startOffset}-`;
     }
-    const config = getSDKConfig();
-    const connectionTimeout = config.httpConnectionTimeoutMs ?? DEFAULT_HTTP_CONNECTION_TIMEOUT_MS;
-    let response;
-    try {
-        response = await withTimeout(fetch(url, {
-            method: "GET",
-            headers,
-            ...(signal && { signal }),
-        }), connectionTimeout);
-    }
-    catch (error) {
-        // Check if it was parent abort
-        if (signal?.aborted) {
-            throw new DownloadCancelledError();
-        }
-        // Connection timeout or network error
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        logger.error(`❌ Connection failed: ${errorMsg}. URL: ${url}`);
-        throw new HTTPError(0, `Connection failed: ${errorMsg}`, error);
-    }
+    // Make the fetch request
+    const response = await fetch(url, {
+        method: "GET",
+        headers,
+        ...(signal && { signal }),
+        // bare-fetch automatically follows redirects
+    });
     if (!response.ok) {
         // Check if it's a 416 (Range Not Satisfiable) - file already complete
         if (response.status === 416 && startOffset > 0) {
-            logger.info(`✅ File already completely downloaded`);
-            // Send 100% progress for already complete file
-            if (progressCallback) {
-                progressCallback({
-                    type: "modelProgress",
-                    downloaded: startOffset,
-                    total: startOffset,
-                    percentage: 100,
-                    downloadKey,
-                });
-            }
+            console.log(`✅ File already completely downloaded`);
             return;
         }
         // Check if server doesn't support range requests
         if (response.status === 200 && startOffset > 0) {
-            logger.warn(`⚠️ Server doesn't support resume, starting fresh download`);
+            console.log(`⚠️ Server doesn't support resume, starting fresh download`);
             startOffset = 0;
             downloadedBytes = 0;
             // Retry without Range header
-            response = await fetch(url, {
+            const freshResponse = await fetch(url, {
                 method: "GET",
                 headers: {
-                    "User-Agent": "qvac-sdk",
+                    "User-Agent": "qvac-sdk/1.0",
                 },
                 ...(signal && { signal }),
             });
-            if (!response.ok) {
-                throw new HTTPError(response.status, response.statusText);
+            if (!freshResponse.ok) {
+                throw new Error(`HTTP error: ${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 HTTPError(response.status, response.statusText);
+            throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
         }
     }
     // Get total size from headers
@@ -166,14 +121,14 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
         // For fresh downloads
         totalBytes = contentLength ? parseInt(contentLength) : 0;
     }
-    logger.info(`📏 Total size: ${totalBytes} bytes (${(totalBytes / 1024 / 1024).toFixed(2)} MB)`);
+    console.log(`📏 Total size: ${totalBytes} bytes (${(totalBytes / 1024 / 1024).toFixed(2)} MB)`);
     // Create write stream (append if resuming)
     const writeStreamOptions = startOffset > 0 && response.status === 206 ? { flags: "a" } : {};
     const writeStream = fs.createWriteStream(modelPath, writeStreamOptions);
     // Get the response body
     const body = response.body;
     if (!body) {
-        throw new NoResponseBodyError();
+        throw new Error("No response body received");
     }
     try {
         // Check if body has pipe method (it's a Node/Bare stream)
@@ -189,7 +144,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                         type: "modelProgress",
                         downloaded: downloadedBytes,
                         total: totalBytes,
-                        percentage: calculatePercentage(downloadedBytes, totalBytes),
+                        percentage: totalBytes > 0 ? (downloadedBytes / totalBytes) * 100 : 0,
                         downloadKey,
                     });
                 }
@@ -209,7 +164,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                     signal.addEventListener("abort", abortHandler);
                 }
                 writeStream.on("finish", () => {
-                    logger.info(`✅ Model downloaded successfully to ${modelPath}`);
+                    console.log(`✅ Model downloaded successfully to ${modelPath}`);
                     if (signal) {
                         signal.removeEventListener("abort", abortHandler);
                     }
@@ -225,7 +180,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                 // Check if abort signal is triggered
                 if (signal && signal.aborted) {
                     writeStream.destroy();
-                    throw new DownloadCancelledError();
+                    throw new Error("Download cancelled");
                 }
                 const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
                 downloadedBytes += buffer.length;
@@ -234,7 +189,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                         type: "modelProgress",
                         downloaded: downloadedBytes,
                         total: totalBytes,
-                        percentage: calculatePercentage(downloadedBytes, totalBytes),
+                        percentage: totalBytes > 0 ? (downloadedBytes / totalBytes) * 100 : 0,
                         downloadKey,
                     });
                 }
@@ -251,7 +206,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
             // Close the write stream
             await new Promise((resolve, reject) => {
                 writeStream.end(() => {
-                    logger.info(`✅ Model downloaded successfully to ${modelPath}`);
+                    console.log(`✅ Model downloaded successfully to ${modelPath}`);
                     resolve();
                 });
                 writeStream.on("error", reject);
@@ -276,7 +231,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                                 type: "modelProgress",
                                 downloaded: downloadedBytes,
                                 total: totalBytes,
-                                percentage: calculatePercentage(downloadedBytes, totalBytes),
+                                percentage: totalBytes > 0 ? (downloadedBytes / totalBytes) * 100 : 0,
                                 downloadKey,
                             });
                         }
@@ -297,41 +252,34 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                 // Close the write stream
                 await new Promise((resolve, reject) => {
                     writeStream.end(() => {
-                        logger.info(`✅ Model downloaded successfully to ${modelPath}`);
+                        console.log(`✅ Model downloaded successfully to ${modelPath}`);
                         resolve();
                     });
                     writeStream.on("error", reject);
                 });
             }
             else {
-                throw new ResponseBodyNotReadableError();
+                throw new Error("Response body is not readable");
             }
         }
     }
     catch (error) {
         writeStream.destroy();
-        logger.error("Error during download:", error instanceof Error ? error.message : String(error));
+        console.error("Error during download:", error instanceof Error ? error.message : String(error));
         throw error instanceof Error ? error : new Error(String(error));
     }
 }
-export async function downloadModelFromHttp(url, progressCallback, hooks) {
-    const filename = extractFilenameFromUrl(url);
-    if (isArchiveUrl(url)) {
-        return downloadShardedModelFromArchive(url, progressCallback, hooks);
-    }
-    const shardInfo = detectShardedModel(filename);
-    if (shardInfo.isSharded && shardInfo.totalShards) {
-        return downloadShardedModelFromHttp(url, progressCallback, hooks);
-    }
+export async function downloadModelFromHttp(url, progressCallback) {
     const downloadKey = createHttpDownloadKey(url);
+    // Check if already downloading
     const existing = getActiveDownload(downloadKey);
     if (existing) {
-        logger.info(`📥 Reusing existing download for: ${downloadKey}`);
-        hooks?.markCacheMiss();
+        console.log(`📥 Reusing existing download for: ${downloadKey}`);
         return existing.promise;
     }
     const cacheDir = getModelsCacheDir();
     const sourceHash = generateShortHash(url);
+    const filename = extractFilenameFromUrl(url);
     const modelPath = `${cacheDir}/${sourceHash}_${filename}`;
     // Create managed download with AbortController
     const abortController = new AbortController();
@@ -340,70 +288,28 @@ export async function downloadModelFromHttp(url, progressCallback, hooks) {
             // Check if already cached
             const cachedPath = await validateCachedFile(modelPath, url, abortController.signal);
             if (cachedPath) {
-                hooks?.markCacheHit();
-                if (progressCallback) {
-                    try {
-                        const stats = await fsPromises.stat(cachedPath);
-                        progressCallback({
-                            type: "modelProgress",
-                            downloaded: stats.size,
-                            total: stats.size,
-                            percentage: 100,
-                            downloadKey,
-                        });
-                    }
-                    catch (error) {
-                        logger.debug("Failed to get file stats for progress callback", {
-                            path: cachedPath,
-                            error,
-                        });
-                    }
-                }
                 return cachedPath;
             }
             // Download the file
-            hooks?.markCacheMiss();
             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 (error) {
-                    logger.debug("Failed to get file stats for final progress update", {
-                        path: modelPath,
-                        error,
-                    });
-                }
-            }
             return modelPath;
         }
         catch (error) {
-            logger.error("❌ Error downloading model:", error instanceof Error ? error.message : String(error));
+            console.error("❌ Error downloading model:", error instanceof Error ? error.message : String(error));
             // Check if we should delete the partial file (clearCache was requested)
             if (error instanceof Error && error.message === "Download cancelled") {
                 if (shouldClearCache(downloadKey)) {
-                    logger.info("🗑️ Clearing cache - deleting partial file");
+                    console.log("🗑️ Clearing cache - deleting partial file");
                     try {
                         await fsPromises.unlink(modelPath);
-                        logger.info(`✅ Deleted partial file: ${modelPath}`);
+                        console.log(`✅ Deleted partial file: ${modelPath}`);
                     }
-                    catch (error) {
-                        logger.debug("Failed to delete partial file during cleanup", {
-                            path: modelPath,
-                            error,
-                        });
+                    catch {
+                        // Ignore cleanup errors
                     }
                 }
                 else {
-                    logger.info("📥 Download paused - partial file preserved for resume");
+                    console.log("📥 Download paused - partial file preserved for resume");
                 }
                 clearClearCacheFlag(downloadKey);
             }
@@ -429,278 +335,3 @@ export async function downloadModelFromHttp(url, progressCallback, hooks) {
     registerDownload(downloadKey, downloadEntry);
     return downloadPromise;
 }
-async function downloadShardedModelFromHttp(shardUrl, progressCallback, hooks) {
-    const config = getSDKConfig();
-    const concurrency = config.httpDownloadConcurrency ?? DEFAULT_CONCURRENCY;
-    const { shardUrls: shardInfos, cacheKey } = parsePatternBasedShardUrl(shardUrl);
-    const downloadKey = `http-sharded:${cacheKey}`;
-    logger.info(`📥 HTTP sharded download: ${shardInfos.length} shards detected from ${shardUrl}`);
-    const existing = getActiveDownload(downloadKey);
-    if (existing) {
-        logger.info(`📥 Reusing existing sharded download for: ${downloadKey}`);
-        hooks?.markCacheMiss();
-        return existing.promise;
-    }
-    const abortController = new AbortController();
-    const shardDir = getShardedModelCacheDir(cacheKey);
-    const downloadPromise = (async () => {
-        try {
-            const shardStates = await Promise.all(shardInfos.map(async (shard, index) => {
-                const shardPath = path.join(shardDir, shard.filename);
-                let expectedSize = 0;
-                try {
-                    const response = await fetch(shard.url, {
-                        method: "HEAD",
-                        signal: abortController.signal,
-                    });
-                    expectedSize = parseInt(response.headers.get("content-length") || "0");
-                }
-                catch (error) {
-                    logger.warn("Failed to get shard size via HEAD request", {
-                        url: shard.url,
-                        error,
-                    });
-                    // expectedSize remains 0, progress percentage will be 0
-                }
-                return {
-                    index,
-                    shard,
-                    shardPath,
-                    expectedSize,
-                    downloadedBytes: 0,
-                    isComplete: false,
-                };
-            }));
-            const overallTotal = shardStates.reduce((sum, s) => sum + s.expectedSize, 0);
-            logger.info(`📏 Total size: ${overallTotal} bytes (${(overallTotal / 1024 / 1024).toFixed(2)} MB)`);
-            const cacheChecks = await Promise.all(shardStates.map(async (state) => {
-                const cached = await validateCachedFile(state.shardPath, state.shard.url, abortController.signal);
-                return { state, isCached: cached !== null };
-            }));
-            const shardsToDownload = cacheChecks
-                .filter((c) => !c.isCached)
-                .map((c) => c.state);
-            for (const check of cacheChecks) {
-                if (check.isCached) {
-                    check.state.isComplete = true;
-                    check.state.downloadedBytes = check.state.expectedSize;
-                }
-            }
-            logger.info(`📥 ${shardsToDownload.length} of ${shardInfos.length} shards need downloading`);
-            if (shardsToDownload.length === 0) {
-                hooks?.markCacheHit();
-            }
-            else {
-                hooks?.markCacheMiss();
-            }
-            await downloadShardsWithConcurrency(shardsToDownload, shardStates, concurrency, abortController.signal, downloadKey, overallTotal, progressCallback);
-            logger.info(`✅ All ${shardInfos.length} shards downloaded successfully`);
-            await extractTensorsFromShards(shardDir, shardInfos[0].filename);
-            return path.join(shardDir, shardInfos[0].filename);
-        }
-        catch (error) {
-            logger.error("❌ Error during sharded download:", error instanceof Error ? error.message : String(error));
-            if (error instanceof Error && error.message === "Download cancelled") {
-                if (shouldClearCache(downloadKey)) {
-                    logger.info("🗑️ Clearing cache - deleting partial shard files");
-                    try {
-                        await fsPromises.rm(shardDir, { recursive: true, force: true });
-                        logger.info(`✅ Deleted shard directory: ${shardDir}`);
-                    }
-                    catch (cleanupError) {
-                        logger.debug("Failed to delete shard directory during cleanup", {
-                            path: shardDir,
-                            error: cleanupError,
-                        });
-                    }
-                }
-            }
-            throw error;
-        }
-        finally {
-            unregisterDownload(downloadKey);
-            clearClearCacheFlag(downloadKey);
-        }
-    })();
-    registerDownload(downloadKey, {
-        key: downloadKey,
-        promise: downloadPromise,
-        abortController,
-        startTime: Date.now(),
-        type: "http",
-        url: shardUrl,
-        modelPath: shardDir,
-    });
-    return downloadPromise;
-}
-async function downloadShardedModelFromArchive(archiveUrl, progressCallback, hooks) {
-    const filename = extractFilenameFromUrl(archiveUrl);
-    const sourceHash = generateShortHash(archiveUrl);
-    const downloadKey = `http-archive:${sourceHash}`;
-    logger.info(`📦 HTTP archive download: ${filename}`);
-    const existing = getActiveDownload(downloadKey);
-    if (existing) {
-        logger.info(`📥 Reusing existing archive download for: ${downloadKey}`);
-        hooks?.markCacheMiss();
-        return existing.promise;
-    }
-    const abortController = new AbortController();
-    const extractDir = getShardedModelCacheDir(sourceHash);
-    const archivePath = path.join(extractDir, `${sourceHash}_${filename}`);
-    const downloadPromise = (async () => {
-        try {
-            await fsPromises.mkdir(extractDir, { recursive: true });
-            const files = await fsPromises.readdir(extractDir);
-            const shardedFile = files.find((f) => detectShardedModel(String(f)).isSharded);
-            if (!shardedFile) {
-                hooks?.markCacheMiss();
-                return downloadAndExtractArchive();
-            }
-            const shardFilename = String(shardedFile);
-            const allShardsExist = await checkAllShardsExist(extractDir, shardFilename);
-            if (!allShardsExist) {
-                logger.warn(`⚠️ Incomplete shards found, re-downloading archive`);
-                hooks?.markCacheMiss();
-                return downloadAndExtractArchive();
-            }
-            const shardFilenames = generateShardFilenames(shardFilename);
-            const firstShard = path.join(extractDir, shardFilenames[0]);
-            const isComplete = await validateShardedModelCache(extractDir, shardFilename);
-            if (isComplete) {
-                logger.info(`✅ Archive already extracted: ${extractDir}`);
-                hooks?.markCacheHit();
-                if (progressCallback) {
-                    progressCallback({
-                        type: "modelProgress",
-                        downloaded: 1,
-                        total: 1,
-                        percentage: 100,
-                        downloadKey,
-                    });
-                }
-                return firstShard;
-            }
-            logger.info(`📝 All shards present but tensors.txt missing, extracting tensors...`);
-            try {
-                await extractTensorsFromShards(extractDir, shardFilename);
-                logger.info(`✅ Tensors extracted successfully`);
-                hooks?.markCacheHit();
-                if (progressCallback) {
-                    progressCallback({
-                        type: "modelProgress",
-                        downloaded: 1,
-                        total: 1,
-                        percentage: 100,
-                        downloadKey,
-                    });
-                }
-                return firstShard;
-            }
-            catch (error) {
-                logger.warn(`Failed to extract tensors, will re-download archive`, {
-                    error,
-                });
-                hooks?.markCacheMiss();
-                return downloadAndExtractArchive();
-            }
-        }
-        catch (error) {
-            logger.error("❌ Error downloading/extracting archive:", error);
-            throw error;
-        }
-        finally {
-            unregisterDownload(downloadKey);
-        }
-        async function downloadAndExtractArchive() {
-            await performHttpDownload(archiveUrl, archivePath, downloadKey, progressCallback, abortController.signal);
-            logger.info(`✅ Archive downloaded, extracting to: ${extractDir}`);
-            const firstShardPath = await extractAndValidateShardedArchive(archivePath, extractDir, abortController.signal);
-            try {
-                await fsPromises.unlink(archivePath);
-                logger.info(`🗑️ Cleaned up archive file: ${archivePath}`);
-            }
-            catch (cleanupError) {
-                logger.debug("Failed to delete archive file during cleanup", {
-                    path: archivePath,
-                    error: cleanupError,
-                });
-            }
-            return firstShardPath;
-        }
-    })();
-    registerDownload(downloadKey, {
-        key: downloadKey,
-        promise: downloadPromise,
-        abortController,
-        startTime: Date.now(),
-        type: "http",
-        url: archiveUrl,
-        modelPath: archivePath,
-    });
-    return downloadPromise;
-}
-async function downloadShardsWithConcurrency(shardsToDownload, allShards, concurrency, signal, downloadKey, overallTotal, progressCallback) {
-    const queue = [...shardsToDownload];
-    const inFlight = new Set();
-    while (queue.length > 0 || inFlight.size > 0) {
-        if (signal.aborted) {
-            throw new DownloadCancelledError();
-        }
-        while (queue.length > 0 && inFlight.size < concurrency) {
-            const state = queue.shift();
-            const downloadPromise = (async () => {
-                logger.info(`📥 Downloading shard ${state.index + 1}: ${state.shard.filename}`);
-                await performHttpDownload(state.shard.url, state.shardPath, downloadKey, (progress) => {
-                    state.downloadedBytes = progress.downloaded;
-                    if (progressCallback) {
-                        const overallDownloaded = allShards.reduce((sum, s) => sum + s.downloadedBytes, 0);
-                        progressCallback({
-                            type: "modelProgress",
-                            downloaded: state.downloadedBytes,
-                            total: state.expectedSize,
-                            percentage: calculatePercentage(state.downloadedBytes, state.expectedSize),
-                            downloadKey,
-                            shardInfo: {
-                                currentShard: state.index + 1,
-                                totalShards: allShards.length,
-                                shardName: state.shard.filename,
-                                overallDownloaded,
-                                overallTotal,
-                                overallPercentage: calculatePercentage(overallDownloaded, overallTotal),
-                            },
-                        });
-                    }
-                }, signal);
-                logger.info(`✅ Shard ${state.index + 1} complete: ${state.shard.filename}`);
-            })().finally(() => {
-                inFlight.delete(downloadPromise);
-            });
-            inFlight.add(downloadPromise);
-        }
-        if (inFlight.size > 0) {
-            await Promise.race(inFlight);
-        }
-    }
-    // Mark all downloaded shards as complete
-    for (const state of shardsToDownload) {
-        state.isComplete = true;
-        state.downloadedBytes = state.expectedSize;
-    }
-    if (progressCallback) {
-        progressCallback({
-            type: "modelProgress",
-            downloaded: overallTotal,
-            total: overallTotal,
-            percentage: 100,
-            downloadKey,
-            shardInfo: {
-                currentShard: allShards.length,
-                totalShards: allShards.length,
-                shardName: allShards[allShards.length - 1].shard.filename,
-                overallDownloaded: overallTotal,
-                overallTotal,
-                overallPercentage: 100,
-            },
-        });
-    }
-}

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

@@ -1,5 +1,4 @@
 import type { ModelProgressUpdate } from "../../../../schemas/index";
-import type { DownloadMetricsHooks } from "./types";
 export declare function deleteCorestoreDirectory(corestoreDir: string): Promise<void>;
-export declare function downloadModelFromHyperdrive(hyperdriveKey: string, modelFileName: string, seed?: boolean, progressCallback?: (progress: ModelProgressUpdate) => void, hooks?: DownloadMetricsHooks, expectedChecksum?: string): Promise<string>;
+export declare function downloadModelFromHyperdrive(hyperdriveKey: string, modelFileName: string, seed?: boolean, progressCallback?: (progress: ModelProgressUpdate) => void, expectedChecksum?: string): Promise<string>;
 //# sourceMappingURL=hyperdrive.d.ts.map