@qvac/sdk 0.5.0 → 0.6.1

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

@@ -1,12 +1,17 @@
 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 { getModelsCacheDir, generateShortHash } from "../../../utils/index.js";
+import { withTimeout } from "../../../../utils/withTimeout.js";
+import { getModelsCacheDir, getShardedModelCacheDir, generateShortHash, detectShardedModel, parsePatternBasedShardUrl, extractTensorsFromShards, calculatePercentage, isArchiveUrl, extractAndValidateShardedArchive, validateShardedModelCache, checkAllShardsExist, generateShardFilenames, hasValidGGUFHeader, } from "../../../utils/index.js";
+import { getSDKConfig } from "../../../bare/registry/config-registry.js";
 import { getActiveDownload, registerDownload, unregisterDownload, createHttpDownloadKey, shouldClearCache, clearClearCacheFlag, } from "./download-manager.js";
-import { DownloadCancelledError, HTTPError, NoResponseBodyError, ResponseBodyNotReadableError, } from "../../../../utils/errors-server.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("/");
@@ -20,17 +25,29 @@ async function validateCachedFile(modelPath, url, signal) {
         await fsPromises.access(modelPath);
         const localStats = await fsPromises.stat(modelPath);
         const localSize = localStats.size;
-        // Get expected size from HEAD request
+        const config = getSDKConfig();
+        const connectionTimeout = config.httpConnectionTimeoutMs ?? DEFAULT_HTTP_CONNECTION_TIMEOUT_MS;
         let expectedSize = 0;
         try {
-            const response = await fetch(url, {
+            const response = await withTimeout(fetch(url, {
                 method: "HEAD",
                 ...(signal && { signal }),
-            });
+            }), connectionTimeout);
             expectedSize = parseInt(response.headers.get("content-length") || "0");
         }
-        catch (error) {
-            logger.warn(`⚠️ Could not get expected file size from HEAD request, will re-download: ${String(error)}`);
+        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;
         }
         if (localSize !== expectedSize) {
@@ -40,8 +57,12 @@ async function validateCachedFile(modelPath, url, signal) {
         logger.info(`✅ Using cached HTTP model: ${modelPath}`);
         return modelPath;
     }
-    catch {
-        // File doesn't exist
+    catch (error) {
+        // Re-throw PartialDownloadOfflineError
+        if (error instanceof PartialDownloadOfflineError) {
+            throw error;
+        }
+        // File doesn't exist or other access error
         return null;
     }
 }
@@ -69,13 +90,26 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
     if (startOffset > 0) {
         headers["Range"] = `bytes=${startOffset}-`;
     }
-    // Make the fetch request
-    const response = await fetch(url, {
-        method: "GET",
-        headers,
-        ...(signal && { signal }),
-        // bare-fetch automatically follows redirects
-    });
+    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);
+    }
     if (!response.ok) {
         // Check if it's a 416 (Range Not Satisfiable) - file already complete
         if (response.status === 416 && startOffset > 0) {
@@ -98,18 +132,16 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
             startOffset = 0;
             downloadedBytes = 0;
             // Retry without Range header
-            const freshResponse = await fetch(url, {
+            response = await fetch(url, {
                 method: "GET",
                 headers: {
-                    "User-Agent": "qvac-sdk/1.0",
+                    "User-Agent": "qvac-sdk",
                 },
                 ...(signal && { signal }),
             });
-            if (!freshResponse.ok) {
-                throw new HTTPError(freshResponse.status, freshResponse.statusText);
+            if (!response.ok) {
+                throw new HTTPError(response.status, response.statusText);
             }
-            // Use the fresh response
-            Object.assign(response, freshResponse);
         }
         else if (response.status !== 206) {
             // 206 is Partial Content (successful resume)
@@ -156,7 +188,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                         type: "modelProgress",
                         downloaded: downloadedBytes,
                         total: totalBytes,
-                        percentage: totalBytes > 0 ? (downloadedBytes / totalBytes) * 100 : 0,
+                        percentage: calculatePercentage(downloadedBytes, totalBytes),
                         downloadKey,
                     });
                 }
@@ -201,7 +233,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                         type: "modelProgress",
                         downloaded: downloadedBytes,
                         total: totalBytes,
-                        percentage: totalBytes > 0 ? (downloadedBytes / totalBytes) * 100 : 0,
+                        percentage: calculatePercentage(downloadedBytes, totalBytes),
                         downloadKey,
                     });
                 }
@@ -243,7 +275,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                                 type: "modelProgress",
                                 downloaded: downloadedBytes,
                                 total: totalBytes,
-                                percentage: totalBytes > 0 ? (downloadedBytes / totalBytes) * 100 : 0,
+                                percentage: calculatePercentage(downloadedBytes, totalBytes),
                                 downloadKey,
                             });
                         }
@@ -282,8 +314,15 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
     }
 }
 export async function downloadModelFromHttp(url, progressCallback) {
+    const filename = extractFilenameFromUrl(url);
+    if (isArchiveUrl(url)) {
+        return downloadShardedModelFromArchive(url, progressCallback);
+    }
+    const shardInfo = detectShardedModel(filename);
+    if (shardInfo.isSharded && shardInfo.totalShards) {
+        return downloadShardedModelFromHttp(url, progressCallback);
+    }
     const downloadKey = createHttpDownloadKey(url);
-    // Check if already downloading
     const existing = getActiveDownload(downloadKey);
     if (existing) {
         logger.info(`📥 Reusing existing download for: ${downloadKey}`);
@@ -291,7 +330,6 @@ export async function downloadModelFromHttp(url, progressCallback) {
     }
     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();
@@ -311,8 +349,11 @@ export async function downloadModelFromHttp(url, progressCallback) {
                             downloadKey,
                         });
                     }
-                    catch {
-                        // Ignore stat errors, file exists but might not be readable
+                    catch (error) {
+                        logger.debug("Failed to get file stats for progress callback", {
+                            path: cachedPath,
+                            error,
+                        });
                     }
                 }
                 return cachedPath;
@@ -331,8 +372,11 @@ export async function downloadModelFromHttp(url, progressCallback) {
                         downloadKey,
                     });
                 }
-                catch {
-                    // Ignore stat errors
+                catch (error) {
+                    logger.debug("Failed to get file stats for final progress update", {
+                        path: modelPath,
+                        error,
+                    });
                 }
             }
             return modelPath;
@@ -347,8 +391,11 @@ export async function downloadModelFromHttp(url, progressCallback) {
                         await fsPromises.unlink(modelPath);
                         logger.info(`✅ Deleted partial file: ${modelPath}`);
                     }
-                    catch {
-                        // Ignore cleanup errors
+                    catch (error) {
+                        logger.debug("Failed to delete partial file during cleanup", {
+                            path: modelPath,
+                            error,
+                        });
                     }
                 }
                 else {
@@ -378,3 +425,265 @@ export async function downloadModelFromHttp(url, progressCallback) {
     registerDownload(downloadKey, downloadEntry);
     return downloadPromise;
 }
+async function downloadShardedModelFromHttp(shardUrl, progressCallback) {
+    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}`);
+        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`);
+            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) {
+    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}`);
+        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) {
+                return downloadAndExtractArchive();
+            }
+            const shardFilename = String(shardedFile);
+            const allShardsExist = await checkAllShardsExist(extractDir, shardFilename);
+            if (!allShardsExist) {
+                logger.warn(`⚠️ Incomplete shards found, re-downloading archive`);
+                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}`);
+                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`);
+                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,
+                });
+                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.js

@@ -6,7 +6,7 @@ import Hyperdrive from "hyperdrive";
 import {} from "bare-stream";
 import { AbortController } from "bare-abort-controller";
 import { getEnv } from "../../../worker.js";
-import { getModelsCacheDir, generateShortHash, detectShardedModel, getShardedModelCacheDir, getShardPath, checkShardCompleteness, calculateFileChecksum, } from "../../../utils/index.js";
+import { getModelsCacheDir, generateShortHash, detectShardedModel, getShardedModelCacheDir, getShardPath, checkShardCompleteness, calculateFileChecksum, extractTensorsFromShards, calculatePercentage, } from "../../../utils/index.js";
 import { getModelBySrc } from "../../../../models/hyperdrive/index.js";
 import { getActiveDownload, registerDownload, unregisterDownload, createHyperdriveDownloadKey, shouldClearCache, clearClearCacheFlag, } from "./download-manager.js";
 import { getSDKConfig } from "../../../bare/registry/config-registry.js";
@@ -265,7 +265,7 @@ async function downloadAndValidateFile(drive, sourceFileName, targetFilePath, ex
                     type: "modelProgress",
                     downloaded: cappedDownloaded,
                     total: totalBytes,
-                    percentage: totalBytes > 0 ? (cappedDownloaded / totalBytes) * 100 : 0,
+                    percentage: calculatePercentage(cappedDownloaded, totalBytes),
                     downloadKey: progressContext.downloadKey,
                 };
                 if (progressContext.shardInfo) {
@@ -394,6 +394,7 @@ async function downloadShardedFilesToFilesystem(hyperdriveKey, firstShardFileNam
                 },
             });
         }
+        await extractTensorsFromShards(shardDir, firstShardFileName);
         return getShardPath(hyperdriveKey, allFiles[0]);
     }
     logger.info(`📥 Need to download ${invalidIndices.length} of ${allFiles.length} files`);
@@ -438,7 +439,7 @@ async function downloadShardedFilesToFilesystem(hyperdriveKey, firstShardFileNam
                             shardName: file,
                             overallDownloaded,
                             overallTotal,
-                            overallPercentage: overallTotal > 0 ? (overallDownloaded / overallTotal) * 100 : 0,
+                            overallPercentage: calculatePercentage(overallDownloaded, overallTotal),
                         },
                     });
                 }
@@ -483,6 +484,7 @@ async function downloadShardedFilesToFilesystem(hyperdriveKey, firstShardFileNam
                 },
             });
         }
+        await extractTensorsFromShards(shardDir, firstShardFileName);
         // Delete corestore directory after successful download (only when not seeding)
         if (!seed) {
             await deleteCorestoreDirectory(corestoreDir);

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

@@ -1,4 +1,4 @@
-export { handleLoadModel } from "../load-model";
-export { downloadModelFromHyperdrive } from "./hyperdrive";
+export { handleLoadModel } from "./handler";
 export { resolveModelPath } from "./resolve";
+export { createCancelFunction } from "./download-manager";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,3 +1,3 @@
-export { handleLoadModel } from "../load-model.js";
-export { downloadModelFromHyperdrive } from "./hyperdrive.js";
+export { handleLoadModel } from "./handler.js";
 export { resolveModelPath } from "./resolve.js";
+export { createCancelFunction } from "./download-manager.js";

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

@@ -1,6 +1,6 @@
 import { models } from "../../../../models/hyperdrive/models.js";
-import { hyperdriveUrlSchema } from "../../../../schemas/index.js";
-import { getModelsCacheDir } from "../../../utils/index.js";
+import { hyperdriveUrlSchema, SUPPORTED_ARCHIVE_EXTENSIONS, } from "../../../../schemas/index.js";
+import { getModelsCacheDir, getShardedModelCacheDir, generateShortHash, extractAndValidateShardedArchive, } from "../../../utils/index.js";
 import { promises as fsPromises } from "bare-fs";
 import path from "bare-path";
 import { downloadModelFromHttp } from "./http.js";
@@ -8,6 +8,10 @@ import { downloadModelFromHyperdrive } from "./hyperdrive.js";
 import { ModelLoadFailedError, ModelNotFoundError, SeedingNotSupportedError, } from "../../../../utils/errors-server.js";
 import { getServerLogger } from "../../../../logging/index.js";
 const logger = getServerLogger();
+function isArchivePath(filePath) {
+    const filename = path.basename(filePath).toLowerCase();
+    return SUPPORTED_ARCHIVE_EXTENSIONS.some((ext) => filename.endsWith(ext));
+}
 /**
  * Resolves a local file path or cached file
  */
@@ -23,6 +27,14 @@ async function resolveLocalOrCachedFile(modelIdOrPath) {
     try {
         await fsPromises.access(cachedPath);
         logger.info(`Loading cached model: ${cachedPath}`);
+        // Check if cached file is an archive
+        if (isArchivePath(cachedPath)) {
+            logger.info(`Extracting cached archive: ${cachedPath}`);
+            const archiveHash = generateShortHash(cachedPath);
+            const extractDir = getShardedModelCacheDir(archiveHash);
+            const extractedPath = await extractAndValidateShardedArchive(cachedPath, extractDir);
+            return extractedPath;
+        }
         return cachedPath;
     }
     catch {
@@ -30,6 +42,14 @@ async function resolveLocalOrCachedFile(modelIdOrPath) {
         try {
             await fsPromises.access(modelIdOrPath);
             logger.info(`Loading local file: ${modelIdOrPath}`);
+            // Check if local file is an archive
+            if (isArchivePath(modelIdOrPath)) {
+                logger.info(`Extracting local archive: ${modelIdOrPath}`);
+                const archiveHash = generateShortHash(modelIdOrPath);
+                const extractDir = getShardedModelCacheDir(archiveHash);
+                const extractedPath = await extractAndValidateShardedArchive(modelIdOrPath, extractDir);
+                return extractedPath;
+            }
             return modelIdOrPath;
         }
         catch {
@@ -70,7 +90,16 @@ export async function resolveModelPath(modelSrc, progressCallback, seed) {
     }
     else if (actualModelSrc.includes("/") || actualModelSrc.includes("\\")) {
         // Handle file paths (absolute or relative with slashes)
-        actualPath = actualModelSrc;
+        // Check if it's a local archive file
+        if (isArchivePath(actualModelSrc)) {
+            logger.info(`Extracting local archive: ${actualModelSrc}`);
+            const archiveHash = generateShortHash(actualModelSrc);
+            const extractDir = getShardedModelCacheDir(archiveHash);
+            actualPath = await extractAndValidateShardedArchive(actualModelSrc, extractDir);
+        }
+        else {
+            actualPath = actualModelSrc;
+        }
     }
     else {
         // Handle local files and cached files

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

@@ -11,11 +11,14 @@ export async function handleLoadModelDelegated(request, progressCallback) {
         throw new ModelLoadFailedError("Delegate information is required for delegated load model");
     }
     const { delegate } = request;
-    const { topic, providerPublicKey, timeout, fallbackToLocal } = delegate;
+    const { topic, providerPublicKey, timeout, fallbackToLocal, forceNewConnection, } = delegate;
     try {
-        logger.info(`📤 Sending delegated loadModel request to provider: ${providerPublicKey}${timeout ? `, timeout: ${timeout}ms` : ""}`);
+        logger.info(`📤 Sending delegated loadModel request to provider: ${providerPublicKey}${timeout ? `, timeout: ${timeout}ms` : ""}${forceNewConnection ? " (forcing new connection)" : ""}`);
         // Create RPC instance for this HyperSwarm peer
-        const rpc = await getRPC(topic, providerPublicKey, { timeout });
+        const rpc = await getRPC(topic, providerPublicKey, {
+            timeout,
+            forceNewConnection,
+        });
         // Strip out the delegate field to avoid infinite delegation
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const { delegate: _, ...providerRequest } = request;

package/dist/server/rpc/handlers/ocr-stream.d.ts

@@ -0,0 +1,3 @@
+import type { OCRStreamRequest, OCRStreamResponse } from "../../../schemas/index";
+export declare function handleOCRStream(request: OCRStreamRequest): AsyncGenerator<OCRStreamResponse>;
+//# sourceMappingURL=ocr-stream.d.ts.map

package/dist/server/rpc/handlers/ocr-stream.js

@@ -0,0 +1,39 @@
+import { ocr } from "../../bare/addons/onnx-ocr/index.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
+export async function* handleOCRStream(request) {
+    const { modelId, image, options } = request;
+    try {
+        // Stream OCR results in real-time
+        for await (const result of ocr({
+            image,
+            modelId,
+            options,
+        })) {
+            if (result.blocks && result.blocks.length > 0) {
+                yield {
+                    type: "ocrStream",
+                    blocks: result.blocks,
+                };
+            }
+            if (result.stats) {
+                yield {
+                    type: "ocrStream",
+                    stats: result.stats,
+                };
+            }
+        }
+        // Signal completion
+        yield {
+            type: "ocrStream",
+            done: true,
+        };
+    }
+    catch (error) {
+        logger.error("Error during OCR:", error);
+        yield {
+            type: "ocrStream",
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}