@qvac/sdk 0.1.0-dev.1760648187.328e967

package/dist/server/rpc/handlers/completion-stream-delegated.d.ts

@@ -0,0 +1,3 @@
+import type { CompletionStreamRequest, CompletionStreamResponse } from "../../../schemas/index";
+export declare function handleCompletionStreamDelegated(request: CompletionStreamRequest): AsyncGenerator<CompletionStreamResponse>;
+//# sourceMappingURL=completion-stream-delegated.d.ts.map

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

@@ -0,0 +1,30 @@
+import { getModelEntry } from "../../bare/registry/model-registry.js";
+import { getRPC } from "../../bare/delegate-rpc-client.js";
+import { stream } from "../../../client/rpc/rpc-client.js";
+export async function* handleCompletionStreamDelegated(request) {
+    // Get delegation info from model registry
+    const entry = getModelEntry(request.modelId);
+    if (!entry?.isDelegated || !entry.delegated) {
+        throw new Error(`Model ${request.modelId} is not a delegated model`);
+    }
+    const { topic, providerPublicKey, timeout } = entry.delegated;
+    try {
+        console.log(`📤 Sending delegated completionStream request to provider: ${providerPublicKey}${timeout ? `, timeout: ${timeout}ms` : ""}`);
+        // Create RPC instance for this HyperSwarm peer
+        const rpc = await getRPC(topic, providerPublicKey, { timeout });
+        // Use the regular stream function with the HyperSwarm RPC instance
+        const responseStream = stream(request, rpc, { timeout });
+        // Yield each response from the stream
+        for await (const response of responseStream) {
+            yield response;
+        }
+    }
+    catch (error) {
+        console.error("Error in delegated completion stream:", error);
+        yield {
+            type: "completionStream",
+            token: `Error communicating with provider: ${error instanceof Error ? error.message : String(error)}`,
+            done: true,
+        };
+    }
+}

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

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

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

@@ -0,0 +1,52 @@
+import { completion } from "../../bare/addons/llamacpp/index.js";
+export async function* handleCompletionStream(request) {
+    try {
+        // Log tools if provided
+        if (request.tools) {
+            console.log("Tools passed to completionStream:", request.tools);
+        }
+        const filteredHistory = request.history.map(({ role, content, attachments }) => ({
+            role,
+            content,
+            attachments: attachments ?? [],
+        }));
+        const stream = completion({
+            history: filteredHistory,
+            modelId: request.modelId,
+            kvCache: request.kvCache,
+        });
+        let stats;
+        let done = false;
+        let buffer = "";
+        while (!done) {
+            const result = await stream.next();
+            if (result.done) {
+                stats = result.value;
+                done = true;
+            }
+            else {
+                buffer += result.value;
+                if (request.stream) {
+                    yield {
+                        type: "completionStream",
+                        token: result.value,
+                    };
+                }
+            }
+        }
+        yield {
+            type: "completionStream",
+            token: buffer,
+            done: true,
+            stats,
+        };
+    }
+    catch (error) {
+        console.error("Error during completion stream:", error);
+        yield {
+            type: "completionStream",
+            token: "",
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}

package/dist/server/rpc/handlers/download-asset.d.ts

@@ -0,0 +1,3 @@
+import type { DownloadAssetRequest, DownloadAssetResponse, ModelProgressUpdate } from "../../../schemas/index";
+export declare function handleDownloadAsset(request: DownloadAssetRequest, progressCallback?: (update: ModelProgressUpdate) => void): Promise<DownloadAssetResponse>;
+//# sourceMappingURL=download-asset.d.ts.map

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

@@ -0,0 +1,21 @@
+import { resolveModelPath } from "./load-model/resolve.js";
+import path from "bare-path";
+export async function handleDownloadAsset(request, progressCallback) {
+    const { assetSrc, seed } = request;
+    try {
+        const assetPath = await resolveModelPath(assetSrc, progressCallback, seed);
+        return {
+            type: "downloadAsset",
+            success: true,
+            assetId: path.basename(assetPath),
+        };
+    }
+    catch (error) {
+        console.error("Error downloading asset:", error);
+        return {
+            type: "downloadAsset",
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { EmbedRequest, EmbedResponse } from "../../../schemas/index";
+export declare function handleEmbed(request: EmbedRequest): Promise<EmbedResponse>;
+//# sourceMappingURL=embed.d.ts.map

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

@@ -0,0 +1,21 @@
+import { embed } from "../../bare/addons/llamacpp/index.js";
+export async function handleEmbed(request) {
+    const { modelId, text } = request;
+    try {
+        const embedding = await embed({ modelId, text });
+        return {
+            type: "embed",
+            success: true,
+            embedding,
+        };
+    }
+    catch (error) {
+        console.error("Error during embedding:", error);
+        return {
+            type: "embed",
+            success: false,
+            embedding: [],
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}

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

@@ -0,0 +1,23 @@
+import { handleCompletionStream } from "./completion-stream";
+import { handleDownloadAsset } from "./download-asset";
+import { handleLoadModel } from "./load-model/index";
+import { handleUnloadModel } from "./unload-model";
+import { handleEmbed } from "./embed";
+import { handleTranscribeStream } from "./transcribe-stream";
+import { provideHandler } from "./provideHandler";
+import { handleTranslate } from "./translate";
+import { handleLoggingStream } from "./logging-stream";
+import { handleRag } from "./rag";
+export declare const handlers: {
+    completionStream: typeof handleCompletionStream;
+    downloadAsset: typeof handleDownloadAsset;
+    loadModel: typeof handleLoadModel;
+    unloadModel: typeof handleUnloadModel;
+    embed: typeof handleEmbed;
+    transcribeStream: typeof handleTranscribeStream;
+    provide: typeof provideHandler;
+    translate: typeof handleTranslate;
+    loggingStream: typeof handleLoggingStream;
+    rag: typeof handleRag;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,22 @@
+import { handleCompletionStream } from "./completion-stream.js";
+import { handleDownloadAsset } from "./download-asset.js";
+import { handleLoadModel } from "./load-model/index.js";
+import { handleUnloadModel } from "./unload-model.js";
+import { handleEmbed } from "./embed.js";
+import { handleTranscribeStream } from "./transcribe-stream.js";
+import { provideHandler } from "./provideHandler.js";
+import { handleTranslate } from "./translate.js";
+import { handleLoggingStream } from "./logging-stream.js";
+import { handleRag } from "./rag.js";
+export const handlers = {
+    completionStream: handleCompletionStream,
+    downloadAsset: handleDownloadAsset,
+    loadModel: handleLoadModel,
+    unloadModel: handleUnloadModel,
+    embed: handleEmbed,
+    transcribeStream: handleTranscribeStream,
+    provide: provideHandler,
+    translate: handleTranslate,
+    loggingStream: handleLoggingStream,
+    rag: handleRag,
+};

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

@@ -0,0 +1,31 @@
+import { type DownloadEntry } from "../../../../schemas/index";
+export declare const getActiveDownload: (key: string) => DownloadEntry | undefined;
+export declare const registerDownload: (key: string, entry: DownloadEntry) => void;
+export declare const unregisterDownload: (key: string) => void;
+export declare const createHyperdriveDownloadKey: (hyperdriveKey: string, modelFileName: string) => string;
+export declare const createHttpDownloadKey: (url: string) => string;
+export declare const getAllActiveDownloads: () => Map<string, DownloadEntry>;
+export declare const setClearCacheFlag: (downloadKey: string, clearCache: boolean) => void;
+export declare const shouldClearCache: (downloadKey: string) => boolean;
+export declare const clearClearCacheFlag: (downloadKey: string) => void;
+export declare const createCancelFunction: (downloadKey: string, clearCache?: boolean) => () => void;
+export declare const cancelAllDownloads: () => void;
+export declare const getDownloadStats: () => {
+    activeCount: number;
+    downloads: ({
+        hyperdriveKey: string;
+        modelFileName: string;
+        key: string;
+        startTime: number;
+        duration: number;
+        type: "hyperdrive" | "http";
+    } | {
+        url: string;
+        modelPath: string;
+        key: string;
+        startTime: number;
+        duration: number;
+        type: "hyperdrive" | "http";
+    })[];
+};
+//# sourceMappingURL=download-manager.d.ts.map

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

@@ -0,0 +1,88 @@
+import {} from "../../../../schemas/index.js";
+import process from "bare-process";
+const activeDownloads = new Map();
+const clearCacheFlags = new Map();
+export const getActiveDownload = (key) => activeDownloads.get(key);
+export const registerDownload = (key, entry) => {
+    activeDownloads.set(key, entry);
+    registerCleanupHandlers();
+};
+export const unregisterDownload = (key) => {
+    activeDownloads.delete(key);
+};
+export const createHyperdriveDownloadKey = (hyperdriveKey, modelFileName) => `${hyperdriveKey}:${modelFileName}`;
+export const createHttpDownloadKey = (url) => `http:${url}`;
+export const getAllActiveDownloads = () => new Map(activeDownloads);
+export const setClearCacheFlag = (downloadKey, clearCache) => {
+    if (clearCache) {
+        clearCacheFlags.set(downloadKey, true);
+    }
+    else {
+        clearCacheFlags.delete(downloadKey);
+    }
+};
+export const shouldClearCache = (downloadKey) => clearCacheFlags.get(downloadKey) ?? false;
+export const clearClearCacheFlag = (downloadKey) => {
+    clearCacheFlags.delete(downloadKey);
+};
+export const createCancelFunction = (downloadKey, clearCache = false) => () => {
+    const entry = getActiveDownload(downloadKey);
+    if (!entry) {
+        return;
+    }
+    // Set flag for the download handlers to check
+    setClearCacheFlag(downloadKey, clearCache);
+    entry.abortController.abort();
+    unregisterDownload(downloadKey);
+};
+export const cancelAllDownloads = () => {
+    console.log(`🧹 Cancelling ${activeDownloads.size} active downloads`);
+    Array.from(activeDownloads.keys()).forEach((key) => createCancelFunction(key)());
+};
+export const getDownloadStats = () => ({
+    activeCount: activeDownloads.size,
+    downloads: Array.from(activeDownloads.entries()).map(([key, entry]) => ({
+        key,
+        startTime: entry.startTime,
+        duration: Date.now() - entry.startTime,
+        type: entry.type,
+        ...(entry.type === "hyperdrive"
+            ? {
+                hyperdriveKey: entry.hyperdriveKey,
+                modelFileName: entry.modelFileName,
+            }
+            : {
+                url: entry.url,
+                modelPath: entry.modelPath,
+            }),
+    })),
+});
+// Register cleanup handlers for graceful shutdown
+let cleanupRegistered = false;
+let isCleaningUp = false;
+const registerCleanupHandlers = () => {
+    if (cleanupRegistered)
+        return;
+    cleanupRegistered = true;
+    const cleanup = async () => {
+        if (isCleaningUp)
+            return;
+        isCleaningUp = true;
+        try {
+            const downloadPromises = Array.from(activeDownloads.values()).map((entry) => entry.promise.catch(() => { }));
+            cancelAllDownloads();
+            if (downloadPromises.length > 0) {
+                await Promise.allSettled(downloadPromises);
+            }
+        }
+        catch (error) {
+            console.error("❌ Error during download cleanup:", error);
+        }
+    };
+    process.on("SIGTERM", () => {
+        void cleanup();
+    });
+    process.on("SIGINT", () => {
+        void cleanup();
+    });
+};

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

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

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

@@ -0,0 +1,337 @@
+import fs, { promises as fsPromises } from "bare-fs";
+import { Readable } from "bare-stream";
+import fetch from "bare-fetch";
+import { AbortController } from "bare-abort-controller";
+import { getModelsCacheDir, generateShortHash } from "../../../utils/index.js";
+import { getActiveDownload, registerDownload, unregisterDownload, createHttpDownloadKey, shouldClearCache, clearClearCacheFlag, } from "./download-manager.js";
+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";
+    return cleanFilename;
+}
+async function validateCachedFile(modelPath, url, signal) {
+    try {
+        await fsPromises.access(modelPath);
+        const localStats = await fsPromises.stat(modelPath);
+        const localSize = localStats.size;
+        // Get expected size from HEAD request
+        let expectedSize = 0;
+        try {
+            const response = await fetch(url, {
+                method: "HEAD",
+                ...(signal && { signal }),
+            });
+            expectedSize = parseInt(response.headers.get("content-length") || "0");
+        }
+        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 (expectedSize > 0 && localSize !== expectedSize) {
+            console.log(`📥 Cached file size mismatch. Expected: ${expectedSize}, Found: ${localSize}. Re-downloading...`);
+            return null;
+        }
+        console.log(`✅ Using cached HTTP model: ${modelPath}`);
+        return modelPath;
+    }
+    catch {
+        // File doesn't exist
+        return null;
+    }
+}
+async function performHttpDownload(url, modelPath, downloadKey, progressCallback, signal) {
+    if (signal?.aborted) {
+        throw new Error("Download cancelled");
+    }
+    console.log(`📥 Downloading model from HTTP: ${url}`);
+    // Check if file exists for resuming
+    let startOffset = 0;
+    let downloadedBytes = 0;
+    try {
+        const existingStats = await fsPromises.stat(modelPath);
+        startOffset = existingStats.size;
+        downloadedBytes = startOffset;
+        console.log(`📥 Resuming download from byte ${startOffset}`);
+    }
+    catch {
+        console.log(`📥 Starting fresh download`);
+    }
+    // Prepare headers for resume if needed
+    const headers = {
+        "User-Agent": "qvac-sdk",
+    };
+    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
+    });
+    if (!response.ok) {
+        // Check if it's a 416 (Range Not Satisfiable) - file already complete
+        if (response.status === 416 && startOffset > 0) {
+            console.log(`✅ File already completely downloaded`);
+            return;
+        }
+        // Check if server doesn't support range requests
+        if (response.status === 200 && startOffset > 0) {
+            console.log(`⚠️ Server doesn't support resume, starting fresh download`);
+            startOffset = 0;
+            downloadedBytes = 0;
+            // Retry without Range header
+            const freshResponse = await fetch(url, {
+                method: "GET",
+                headers: {
+                    "User-Agent": "qvac-sdk/1.0",
+                },
+                ...(signal && { signal }),
+            });
+            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 Error(`HTTP error: ${response.status} ${response.statusText}`);
+        }
+    }
+    // Get total size from headers
+    let totalBytes = 0;
+    const contentLength = response.headers.get("content-length");
+    if (response.status === 206) {
+        // For resumed downloads, parse Content-Range header
+        const contentRange = response.headers.get("content-range");
+        if (contentRange) {
+            const match = contentRange.match(/bytes \d+-\d+\/(\d+)/);
+            if (match && match[1]) {
+                totalBytes = parseInt(match[1]);
+            }
+        }
+    }
+    else {
+        // For fresh downloads
+        totalBytes = contentLength ? parseInt(contentLength) : 0;
+    }
+    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 Error("No response body received");
+    }
+    try {
+        // Check if body has pipe method (it's a Node/Bare stream)
+        const isReadable = body instanceof Readable ||
+            (typeof body.pipe === "function" &&
+                typeof body.on === "function");
+        if (isReadable) {
+            // Track progress by intercepting data events if possible
+            body.on("data", (chunk) => {
+                downloadedBytes += chunk.length;
+                if (progressCallback) {
+                    progressCallback({
+                        type: "modelProgress",
+                        downloaded: downloadedBytes,
+                        total: totalBytes,
+                        percentage: totalBytes > 0 ? (downloadedBytes / totalBytes) * 100 : 0,
+                        downloadKey,
+                    });
+                }
+            });
+            // Pipe directly to file
+            body.pipe(writeStream);
+            // Wait for download to complete
+            await new Promise((resolve, reject) => {
+                // Handle abort signal
+                const abortHandler = () => {
+                    const error = new Error("Download cancelled");
+                    body.destroy();
+                    writeStream.destroy();
+                    reject(error);
+                };
+                if (signal) {
+                    signal.addEventListener("abort", abortHandler);
+                }
+                writeStream.on("finish", () => {
+                    console.log(`✅ Model downloaded successfully to ${modelPath}`);
+                    if (signal) {
+                        signal.removeEventListener("abort", abortHandler);
+                    }
+                    resolve(undefined);
+                });
+                writeStream.on("error", reject);
+                body.on("error", reject);
+            });
+        }
+        else if (body[Symbol.asyncIterator]) {
+            // Body is an async iterable (for await...of)
+            for await (const chunk of body) {
+                // Check if abort signal is triggered
+                if (signal && signal.aborted) {
+                    writeStream.destroy();
+                    throw new Error("Download cancelled");
+                }
+                const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                downloadedBytes += buffer.length;
+                if (progressCallback) {
+                    progressCallback({
+                        type: "modelProgress",
+                        downloaded: downloadedBytes,
+                        total: totalBytes,
+                        percentage: totalBytes > 0 ? (downloadedBytes / totalBytes) * 100 : 0,
+                        downloadKey,
+                    });
+                }
+                // Write chunk to file
+                await new Promise((resolve, reject) => {
+                    writeStream.write(buffer, (err) => {
+                        if (err)
+                            reject(new Error(err instanceof Error ? err.message : String(err)));
+                        else
+                            resolve();
+                    });
+                });
+            }
+            // Close the write stream
+            await new Promise((resolve, reject) => {
+                writeStream.end(() => {
+                    console.log(`✅ Model downloaded successfully to ${modelPath}`);
+                    resolve();
+                });
+                writeStream.on("error", reject);
+            });
+        }
+        else {
+            // Fallback: try to use getReader() if it's a ReadableStream
+            const readableStreamBody = body;
+            const reader = readableStreamBody.getReader
+                ? readableStreamBody.getReader()
+                : null;
+            if (reader) {
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        const buffer = Buffer.from(value);
+                        downloadedBytes += buffer.length;
+                        if (progressCallback) {
+                            progressCallback({
+                                type: "modelProgress",
+                                downloaded: downloadedBytes,
+                                total: totalBytes,
+                                percentage: totalBytes > 0 ? (downloadedBytes / totalBytes) * 100 : 0,
+                                downloadKey,
+                            });
+                        }
+                        // Write chunk to file
+                        await new Promise((resolve, reject) => {
+                            writeStream.write(buffer, (err) => {
+                                if (err)
+                                    reject(new Error(err instanceof Error ? err.message : String(err)));
+                                else
+                                    resolve();
+                            });
+                        });
+                    }
+                }
+                finally {
+                    reader.releaseLock();
+                }
+                // Close the write stream
+                await new Promise((resolve, reject) => {
+                    writeStream.end(() => {
+                        console.log(`✅ Model downloaded successfully to ${modelPath}`);
+                        resolve();
+                    });
+                    writeStream.on("error", reject);
+                });
+            }
+            else {
+                throw new Error("Response body is not readable");
+            }
+        }
+    }
+    catch (error) {
+        writeStream.destroy();
+        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) {
+    const downloadKey = createHttpDownloadKey(url);
+    // Check if already downloading
+    const existing = getActiveDownload(downloadKey);
+    if (existing) {
+        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();
+    const downloadPromise = (async () => {
+        try {
+            // Check if already cached
+            const cachedPath = await validateCachedFile(modelPath, url, abortController.signal);
+            if (cachedPath) {
+                return cachedPath;
+            }
+            // Download the file
+            await performHttpDownload(url, modelPath, downloadKey, progressCallback, abortController.signal);
+            return modelPath;
+        }
+        catch (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)) {
+                    console.log("🗑️ Clearing cache - deleting partial file");
+                    try {
+                        await fsPromises.unlink(modelPath);
+                        console.log(`✅ Deleted partial file: ${modelPath}`);
+                    }
+                    catch {
+                        // Ignore cleanup errors
+                    }
+                }
+                else {
+                    console.log("📥 Download paused - partial file preserved for resume");
+                }
+                clearClearCacheFlag(downloadKey);
+            }
+            const errorToThrow = error instanceof Error ? error : new Error(String(error));
+            throw errorToThrow;
+        }
+        finally {
+            // Cleanup from download manager
+            unregisterDownload(downloadKey);
+        }
+    })();
+    // Register download
+    const downloadEntry = {
+        key: downloadKey,
+        promise: downloadPromise,
+        abortController,
+        startTime: Date.now(),
+        type: "http",
+        url,
+        modelPath,
+        ...(progressCallback && { onProgress: progressCallback }),
+    };
+    registerDownload(downloadKey, downloadEntry);
+    return downloadPromise;
+}

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

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