@qvac/sdk 0.1.0-dev.1760648187.328e967

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

@@ -0,0 +1,332 @@
+import fs, { promises as fsPromises } from "bare-fs";
+import path from "bare-path";
+import crypto from "bare-crypto";
+import Corestore from "corestore";
+import Hyperswarm, {} from "hyperswarm";
+import Hyperdrive from "hyperdrive";
+import {} from "bare-stream";
+import { AbortController } from "bare-abort-controller";
+import { getEnv } from "../../../worker.js";
+import { getModelsCacheDir, generateShortHash } from "../../../utils/index.js";
+import { getModelBySrc } from "../../../../models/hyperdrive/index.js";
+import { getActiveDownload, registerDownload, unregisterDownload, createHyperdriveDownloadKey, shouldClearCache, clearClearCacheFlag, } from "./download-manager.js";
+async function setupHyperdrive(hyperdriveKey, corestoreDir) {
+    const corestore = new Corestore(corestoreDir);
+    await corestore.ready();
+    const drive = new Hyperdrive(corestore, Buffer.from(hyperdriveKey, "hex"));
+    await drive.ready();
+    const swarm = new Hyperswarm();
+    swarm.join(drive.discoveryKey, { server: false, client: true });
+    swarm.on("connection", (connection) => {
+        console.log(`🤝 Connected to peer for hyperdrive download`);
+        drive.replicate(connection);
+    });
+    const doneFindingPeers = drive.findingPeers();
+    await swarm.flush();
+    doneFindingPeers();
+    return { corestore, drive, swarm, corestoreDir };
+}
+async function cleanupHyperdrive(setup) {
+    console.log("🧹 Cleaning up hyperdrive setup");
+    await setup.swarm.destroy();
+    await setup.drive.close();
+    await setup.corestore.close();
+}
+export async function deleteCorestoreDirectory(corestoreDir) {
+    console.log(`🗑️ DELETING corestore directory... ${corestoreDir}`);
+    try {
+        await fsPromises.rm(corestoreDir, { recursive: true, force: true });
+    }
+    catch (e) {
+        console.error(`Error deleting corestore directory: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+async function findFileInHyperdrive(drive, modelFileName) {
+    const paths = [modelFileName, `/${modelFileName}`, `./${modelFileName}`];
+    let entry = null;
+    let targetPath = modelFileName;
+    for (const pathVariation of paths) {
+        try {
+            entry = await drive.entry(pathVariation);
+            if (entry) {
+                targetPath = pathVariation;
+                break;
+            }
+        }
+        catch {
+            // Continue trying other paths
+        }
+    }
+    if (!entry) {
+        // Try listing available files to help debug
+        try {
+            const rootFiles = drive.list("/", false);
+            const availableFiles = [];
+            for await (const file of rootFiles) {
+                availableFiles.push(file.key);
+            }
+            if (availableFiles.length === 0) {
+                // Try without leading slash
+                const noSlashFiles = drive.list("", false);
+                for await (const file of noSlashFiles) {
+                    availableFiles.push(file.key);
+                }
+            }
+            throw new Error(`File ${modelFileName} not found in hyperdrive. Available files: ${availableFiles.join(", ")}`);
+        }
+        catch (listError) {
+            throw new Error(`File ${modelFileName} not found in hyperdrive. Could not list available files: ${listError instanceof Error ? listError.message : String(listError)}`);
+        }
+    }
+    return { entry, targetPath };
+}
+async function validateFileChecksum(filePath, expectedChecksum) {
+    console.log(`🔍 Validating SHA256 checksum...`);
+    return new Promise((resolve) => {
+        try {
+            const hash = crypto.createHash("sha256");
+            const stream = fs.createReadStream(filePath);
+            stream.on("data", (chunk) => {
+                hash.update(chunk);
+            });
+            stream.on("end", () => {
+                const actualChecksum = hash.digest("hex");
+                console.log(`Expected: ${String(expectedChecksum)}`);
+                console.log(`Actual:   ${String(actualChecksum)}`);
+                const isValid = actualChecksum === expectedChecksum;
+                if (isValid) {
+                    console.log(`✅ Checksum validation passed!`);
+                }
+                else {
+                    console.log(`❌ Checksum validation FAILED! File may be corrupted.`);
+                }
+                resolve(isValid);
+            });
+            stream.on("error", (error) => {
+                console.error(`❌ Error validating checksum: ${error.message}`);
+                resolve(false);
+            });
+        }
+        catch (error) {
+            console.error(`❌ Error validating checksum: ${error instanceof Error ? error.message : String(error)}`);
+            resolve(false);
+        }
+    });
+}
+async function validateCachedFile(modelPath, modelFileName, expectedSize, expectedChecksum) {
+    try {
+        await fsPromises.access(modelPath);
+        const localStats = await fsPromises.stat(modelPath);
+        const localSize = localStats.size;
+        // For hyperdrive: only validate if file is complete
+        // Partial files are ignored - corestore state is the source of truth for resume
+        if (localSize === expectedSize) {
+            console.log(`✅ Model cached with correct size: ${modelPath}`);
+            // Always validate checksum if provided, even when size matches
+            if (expectedChecksum && expectedChecksum.length === 64) {
+                const isValid = await validateFileChecksum(modelPath, expectedChecksum);
+                if (isValid) {
+                    return modelPath;
+                }
+                else {
+                    throw new Error(`File ${modelFileName} is fully downloaded but checksum validation failed. Expected: ${expectedChecksum}. File may be corrupted.`);
+                }
+            }
+            else {
+                console.log(`✅ Model already cached and size validated: ${modelPath}`);
+                return modelPath;
+            }
+        }
+        // File exists but incomplete - will be overwritten during download
+        // Resume state will be determined by corestore blocks, not file size
+        return null;
+    }
+    catch {
+        // Model doesn't exist, need to download
+        return null;
+    }
+}
+async function performHyperdriveDownload(modelPath, modelFileName, hyperdriveKey, corestoreDir, downloadKey, progressCallback, seed, signal) {
+    // Check if already aborted
+    if (signal?.aborted) {
+        throw new Error("Download cancelled");
+    }
+    console.log(`Downloading model from hyperdrive ${hyperdriveKey} to ${modelPath}`);
+    const setup = await setupHyperdrive(hyperdriveKey, corestoreDir);
+    let downloadedBytes = 0;
+    let totalBytes = 0;
+    // Set up abort handler
+    let readStream;
+    let writeStream;
+    const cleanup = () => {
+        console.log("🛑 Aborting hyperdrive download...");
+        // Destroy streams if they exist
+        if (readStream) {
+            readStream.destroy();
+        }
+        if (writeStream) {
+            writeStream.destroy();
+        }
+    };
+    signal?.addEventListener("abort", cleanup);
+    try {
+        const result = await findFileInHyperdrive(setup.drive, modelFileName);
+        const { entry, targetPath } = result;
+        totalBytes = entry?.value?.blob?.byteLength || 0;
+        console.log(`📏 Model size: ${totalBytes} bytes (${(totalBytes / 1024 / 1024).toFixed(2)} MB)`);
+        // Get blobs and file blob range
+        const blobs = await setup.drive.getBlobs();
+        const blob = entry?.value?.blob;
+        if (!blob) {
+            throw new Error(`No blob found for ${modelFileName}`);
+        }
+        // Check what blocks are already downloaded in corestore for this specific file
+        let alreadyDownloaded = 0;
+        for (let i = blob.blockOffset; i < blob.blockOffset + blob.blockLength; i++) {
+            const hasBlock = await blobs.core.has(i);
+            if (hasBlock) {
+                alreadyDownloaded++;
+            }
+        }
+        downloadedBytes = 0;
+        if (alreadyDownloaded > 0) {
+            console.log(`📥 Resuming download (${alreadyDownloaded}/${blob.blockLength} blocks already in corestore)`);
+        }
+        else {
+            console.log(`📥 Starting fresh download`);
+        }
+        // Track only downloads for blocks within our file's blob range
+        blobs.core.on("download", (index, bytes) => {
+            if (index >= blob.blockOffset &&
+                index < blob.blockOffset + blob.blockLength) {
+                downloadedBytes += bytes;
+                if (progressCallback) {
+                    progressCallback({
+                        type: "modelProgress",
+                        downloaded: downloadedBytes,
+                        total: totalBytes,
+                        percentage: totalBytes > 0 ? (downloadedBytes / totalBytes) * 100 : 0,
+                        downloadKey,
+                    });
+                }
+            }
+        });
+        // Check if aborted before starting streams
+        if (signal?.aborted) {
+            throw new Error("Download cancelled");
+        }
+        // Trigger download for this file (hyperdrive will only download missing blocks)
+        setup.drive.download(targetPath);
+        readStream = setup.drive.createReadStream(targetPath);
+        writeStream = fs.createWriteStream(modelPath);
+        // Pipe the streams
+        readStream.pipe(writeStream);
+        // Wait for download to complete
+        await new Promise((resolve, reject) => {
+            writeStream.on("finish", () => resolve(undefined));
+            writeStream.on("error", reject);
+            readStream.on("error", reject);
+            // Also reject on abort
+            if (signal) {
+                signal.addEventListener("abort", () => {
+                    reject(new Error("Download cancelled"));
+                }, { once: true });
+            }
+        });
+        console.log(`✅ Model downloaded successfully to ${modelPath}`);
+        // Delete corestore directory after successful download (only when not seeding, to save space)
+        if (!seed) {
+            await deleteCorestoreDirectory(setup.corestoreDir);
+        }
+    }
+    catch (error) {
+        console.error("❌ Error during hyperdrive download:", error instanceof Error ? error.message : String(error));
+        // Preserve cancellation errors
+        if (error instanceof Error && error.message === "Download cancelled") {
+            throw error;
+        }
+        throw new Error(`Download failed for ${modelFileName} from hyperdrive: ${hyperdriveKey}`);
+    }
+    finally {
+        signal?.removeEventListener("abort", cleanup);
+        if (!seed) {
+            await cleanupHyperdrive(setup);
+        }
+        // Only delete corestore and partial file if user explicitly requested clearCache
+        if (signal?.aborted) {
+            if (shouldClearCache(downloadKey)) {
+                try {
+                    await fsPromises.unlink(modelPath);
+                }
+                catch {
+                    // no-op
+                }
+                await deleteCorestoreDirectory(corestoreDir);
+            }
+            clearClearCacheFlag(downloadKey);
+        }
+    }
+}
+export async function downloadModelFromHyperdrive(hyperdriveKey, modelFileName, seed, progressCallback, expectedChecksum) {
+    const downloadKey = createHyperdriveDownloadKey(hyperdriveKey, modelFileName);
+    // Check if already downloading
+    const existing = getActiveDownload(downloadKey);
+    if (existing) {
+        return existing.promise;
+    }
+    const corestoreDir = path.join(getEnv().HOME_DIR, ".qvac", "corestore", hyperdriveKey);
+    const cacheDir = getModelsCacheDir();
+    const sourceHash = generateShortHash(`${hyperdriveKey}/${modelFileName}`);
+    const modelPath = path.join(cacheDir, `${sourceHash}_${modelFileName}`);
+    // Get model definition to get expected size (if it's a known model)
+    const model = getModelBySrc(modelFileName, hyperdriveKey);
+    // First, check if we already have a valid cached file (only if we have model metadata)
+    if (model) {
+        const cachedPath = await validateCachedFile(modelPath, modelFileName, model.expectedSize, expectedChecksum || model.sha256Checksum);
+        if (cachedPath) {
+            // Delete any leftover corestore directory from previous runs (only when not seeding)
+            if (!seed) {
+                await deleteCorestoreDirectory(corestoreDir);
+            }
+            return cachedPath;
+        }
+    }
+    // Create managed download with AbortController
+    const abortController = new AbortController();
+    const downloadPromise = (async () => {
+        try {
+            // Download the file from hyperdrive
+            await performHyperdriveDownload(modelPath, modelFileName, hyperdriveKey, corestoreDir, downloadKey, progressCallback, seed, abortController.signal);
+            // Validate checksum using provided checksum or model's checksum (if available)
+            const checksumToValidate = expectedChecksum || model?.sha256Checksum;
+            if (checksumToValidate && checksumToValidate.length === 64) {
+                const isValid = await validateFileChecksum(modelPath, checksumToValidate);
+                if (!isValid) {
+                    await fsPromises.unlink(modelPath);
+                    throw new Error(`Checksum validation failed for ${modelFileName}`);
+                }
+            }
+            else {
+                console.log(`⚠️  No valid checksum available for validation`);
+            }
+            return modelPath;
+        }
+        finally {
+            // Cleanup from download manager
+            unregisterDownload(downloadKey);
+        }
+    })();
+    // Register download
+    const downloadEntry = {
+        key: downloadKey,
+        promise: downloadPromise,
+        abortController,
+        startTime: Date.now(),
+        type: "hyperdrive",
+        hyperdriveKey,
+        modelFileName,
+        ...(progressCallback && { onProgress: progressCallback }),
+    };
+    registerDownload(downloadKey, downloadEntry);
+    return downloadPromise;
+}

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

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

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

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

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

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

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

@@ -0,0 +1,121 @@
+import { getModelBySrc, models } from "../../../../models/hyperdrive/models.js";
+import { hyperdriveUrlSchema } from "../../../../schemas/index.js";
+import { getModelsCacheDir } from "../../../utils/index.js";
+import { promises as fsPromises } from "bare-fs";
+import path from "bare-path";
+import { downloadModelFromHttp } from "./http.js";
+import { downloadModelFromHyperdrive } from "./hyperdrive.js";
+/**
+ * Attempts to resolve a model from cache (without validation)
+ * Validation will be handled by the hyperdrive download logic
+ */
+async function tryResolveCachedModel(modelId) {
+    const cacheDir = getModelsCacheDir();
+    const cachedPath = path.join(cacheDir, modelId);
+    try {
+        await fsPromises.access(cachedPath);
+        // File exists - return null to let hyperdrive validation handle size/checksum
+        // This ensures partial downloads are properly resumed instead of being
+        // incorrectly validated and deleted
+        return null;
+    }
+    catch {
+        // File doesn't exist
+        return null;
+    }
+}
+/**
+ * Resolves a known model by ID from hyperdrive, checking cache first
+ */
+async function resolveKnownModel(model, modelIdOrPath, progressCallback, seed) {
+    if (!model) {
+        throw new Error("Model is null");
+    }
+    console.log(`Loading model ID '${modelIdOrPath}' from hyperdrive`);
+    // Try to resolve from cache first
+    const cachedPath = await tryResolveCachedModel(model.modelId);
+    if (cachedPath) {
+        return cachedPath;
+    }
+    // Not cached or invalid, download from hyperdrive
+    const downloadedPath = await downloadModelFromHyperdrive(model.hyperdriveKey, model.modelId, seed, progressCallback, model.sha256Checksum);
+    return downloadedPath;
+}
+/**
+ * Resolves a local file path or cached file
+ */
+async function resolveLocalOrCachedFile(modelIdOrPath) {
+    // Check if it's a hex string (arbitrary hyperdrive key)
+    const isHexString = /^[0-9a-fA-F]{64}$/.test(modelIdOrPath);
+    if (isHexString) {
+        throw new Error(`Direct hyperdrive keys not supported. Use hyperdriveKey parameter instead. Example: loadModel("model.gguf", "${modelIdOrPath}")`);
+    }
+    // Check if it's a cached file or local file
+    const cacheDir = getModelsCacheDir();
+    const cachedPath = path.join(cacheDir, modelIdOrPath);
+    try {
+        await fsPromises.access(cachedPath);
+        console.log(`Loading cached model: ${cachedPath}`);
+        return cachedPath;
+    }
+    catch {
+        // Try as local file in current directory
+        try {
+            await fsPromises.access(modelIdOrPath);
+            console.log(`Loading local file: ${modelIdOrPath}`);
+            return modelIdOrPath;
+        }
+        catch {
+            // Invalid model ID - provide helpful error
+            const availableModels = models.map((m) => m.modelId);
+            throw new Error(`Invalid model ID: "${modelIdOrPath}". Available models: ${availableModels.join(", ")}`);
+        }
+    }
+}
+export async function resolveModelPath(modelSrc, progressCallback, seed) {
+    // Parse hyperdrive URLs if present
+    let hyperdriveKey;
+    let actualModelSrc = modelSrc;
+    if (modelSrc.startsWith("pear://")) {
+        const { key, path } = hyperdriveUrlSchema.parse(modelSrc);
+        hyperdriveKey = key;
+        actualModelSrc = path;
+    }
+    let actualPath;
+    // Validate seeding is only used with hyperdrive models
+    if (seed && !hyperdriveKey) {
+        const model = getModelBySrc(actualModelSrc);
+        if (!model) {
+            throw new Error("Seeding is only supported for hyperdrive models");
+        }
+    }
+    // Check if it's an HTTP/HTTPS URL
+    if (actualModelSrc.startsWith("http://") ||
+        actualModelSrc.startsWith("https://")) {
+        console.log(`Loading from HTTP URL: ${actualModelSrc}`);
+        actualPath = await downloadModelFromHttp(actualModelSrc, progressCallback);
+        console.log(`Loaded Model to ${actualPath}`);
+    }
+    else if (hyperdriveKey) {
+        // Direct hyperdrive loading
+        console.log(`Loading from hyperdrive: ${hyperdriveKey}`);
+        actualPath = await downloadModelFromHyperdrive(hyperdriveKey, actualModelSrc, seed, progressCallback);
+    }
+    else {
+        // Try to resolve as a known model ID
+        const model = getModelBySrc(actualModelSrc);
+        if (model) {
+            actualPath = await resolveKnownModel(model, actualModelSrc, progressCallback, seed);
+        }
+        else if (actualModelSrc.includes("/") || actualModelSrc.includes("\\")) {
+            // Handle file paths (absolute or relative with slashes)
+            console.log(`Loading from file: ${actualModelSrc}`);
+            actualPath = actualModelSrc;
+        }
+        else {
+            // Handle local files and cached files
+            actualPath = await resolveLocalOrCachedFile(actualModelSrc);
+        }
+    }
+    return actualPath;
+}

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

@@ -0,0 +1,3 @@
+import type { LoadModelRequest, LoadModelResponse, ModelProgressUpdate } from "../../../schemas/index";
+export declare function handleLoadModelDelegated(request: LoadModelRequest, progressCallback?: (update: ModelProgressUpdate) => void): Promise<LoadModelResponse>;
+//# sourceMappingURL=load-model-delegated.d.ts.map

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

@@ -0,0 +1,93 @@
+import { registerModel } from "../../bare/registry/model-registry.js";
+import { getRPC } from "../../bare/delegate-rpc-client.js";
+import { send, stream } from "../../../client/rpc/rpc-client.js";
+import { handleLoadModel } from "./load-model/index.js";
+export async function handleLoadModelDelegated(request, progressCallback) {
+    if (!request.delegate) {
+        throw new Error("Delegate information is required for delegated load model");
+    }
+    const { delegate } = request;
+    const { topic, providerPublicKey, timeout, fallbackToLocal } = delegate;
+    try {
+        console.log(`📤 Sending delegated loadModel request to provider: ${providerPublicKey}${timeout ? `, timeout: ${timeout}ms` : ""}`);
+        // Create RPC instance for this HyperSwarm peer
+        const rpc = await getRPC(topic, providerPublicKey, { timeout });
+        // Strip out the delegate field to avoid infinite delegation
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { delegate: _, ...providerRequest } = request;
+        let finalResponse;
+        if (request.withProgress) {
+            // Use streaming for progress updates
+            console.log("📊 Using streaming mode for loadModel with progress");
+            const responseStream = stream(providerRequest, rpc, timeout ? { timeout } : {});
+            for await (const response of responseStream) {
+                if (response.type === "modelProgress") {
+                    // Forward progress updates to the client
+                    if (progressCallback) {
+                        progressCallback(response);
+                    }
+                }
+                else if (response.type === "loadModel") {
+                    finalResponse = response;
+                    break;
+                }
+            }
+            if (!finalResponse) {
+                throw new Error("No final response received from provider");
+            }
+        }
+        else {
+            // Use simple send for non-progress requests
+            console.log("📤 Using simple send mode for loadModel");
+            finalResponse = (await send(providerRequest, rpc, timeout ? { timeout } : {}));
+        }
+        if (!finalResponse || !finalResponse.success) {
+            console.error("Provider failed to load model:", finalResponse?.error);
+            return {
+                type: "loadModel",
+                success: false,
+                error: `Provider failed to load model: ${finalResponse?.error || "Unknown error"}`,
+            };
+        }
+        // Register the delegated model with provider info
+        const modelId = finalResponse.modelId || request.modelSrc || `delegated-${Date.now()}`;
+        const delegateOptions = {
+            topic,
+            providerPublicKey,
+        };
+        if (timeout !== undefined) {
+            delegateOptions.timeout = timeout;
+        }
+        registerModel(modelId, delegateOptions);
+        console.log(`✅ Delegated model registered: ${modelId} -> provider: ${providerPublicKey}`);
+        return {
+            type: "loadModel",
+            success: true,
+            modelId,
+        };
+    }
+    catch (error) {
+        console.error("Error in delegated load model:", error);
+        if (fallbackToLocal) {
+            console.log("🔄 Fallback to local model loading enabled, attempting local load...");
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { delegate: _, ...localRequest } = request;
+                return await handleLoadModel(localRequest, progressCallback);
+            }
+            catch (localError) {
+                console.error("❌ Local fallback also failed:", localError);
+                return {
+                    type: "loadModel",
+                    success: false,
+                    error: `Both delegated and local loading failed. Delegated error: ${error instanceof Error ? error.message : String(error)}. Local error: ${localError instanceof Error ? localError.message : String(localError)}`,
+                };
+            }
+        }
+        return {
+            type: "loadModel",
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { LoadModelRequest, LoadModelResponse, ModelProgressUpdate } from "../../../schemas/index";
+export declare function handleLoadModel(request: LoadModelRequest, progressCallback?: (update: ModelProgressUpdate) => void): Promise<LoadModelResponse>;
+//# sourceMappingURL=load-model.d.ts.map

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

@@ -0,0 +1,41 @@
+import { loadModel } from "../../bare/addons/index.js";
+import { resolveModelPath } from "./load-model/resolve.js";
+import { generateShortHash } from "../../utils/index.js";
+export async function handleLoadModel(request, progressCallback) {
+    const { modelSrc, seed, projectionModelSrc, vadModelSrc } = request;
+    try {
+        const modelPath = await resolveModelPath(modelSrc, progressCallback, seed);
+        let projectionModelPath;
+        if (projectionModelSrc) {
+            projectionModelPath = await resolveModelPath(projectionModelSrc, progressCallback, seed);
+        }
+        let vadModelPath;
+        if (vadModelSrc) {
+            vadModelPath = await resolveModelPath(vadModelSrc, progressCallback, seed);
+        }
+        // Generate hash-based modelId
+        const configStr = JSON.stringify(request.modelConfig, Object.keys(request.modelConfig).sort());
+        const modelHashInput = `${request.modelType}:${modelSrc}:${configStr}`;
+        const modelId = generateShortHash(modelHashInput);
+        await loadModel({
+            modelId,
+            modelPath,
+            options: request,
+            projectionModelPath,
+            vadModelPath,
+        });
+        return {
+            type: "loadModel",
+            success: true,
+            modelId,
+        };
+    }
+    catch (error) {
+        console.error("Error loading model:", error);
+        return {
+            type: "loadModel",
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}

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

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

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

@@ -0,0 +1,37 @@
+import { registerLoggingStream, unregisterLoggingStream, } from "../../bare/registry/logging-stream-registry.js";
+export async function* handleLoggingStream(request) {
+    const { modelId } = request;
+    const logQueue = [];
+    let pendingResolve = null;
+    const streamHandler = (level, namespace, message) => {
+        const logResponse = {
+            type: "loggingStream",
+            modelId,
+            level: level,
+            namespace,
+            message,
+            timestamp: Date.now(),
+        };
+        logQueue.push(logResponse);
+        if (pendingResolve) {
+            const resolve = pendingResolve;
+            pendingResolve = null;
+            resolve();
+        }
+    };
+    registerLoggingStream(modelId, streamHandler);
+    try {
+        while (true) {
+            while (logQueue.length > 0) {
+                yield logQueue.shift();
+            }
+            // Wait for new logs - stream will terminate when client disconnects
+            await new Promise((resolve) => {
+                pendingResolve = resolve;
+            });
+        }
+    }
+    finally {
+        unregisterLoggingStream(modelId, streamHandler);
+    }
+}

package/dist/server/rpc/handlers/provideHandler/connection.d.ts

@@ -0,0 +1,3 @@
+import type Hyperswarm from "hyperswarm";
+export declare function setupConnectionHandlers(swarm: Hyperswarm): void;
+//# sourceMappingURL=connection.d.ts.map