@qvac/sdk 0.4.1 → 0.6.0

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

@@ -6,11 +6,13 @@ 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";
 import { FileNotFoundError, ChecksumValidationFailedError, DownloadCancelledError, HyperdriveDownloadFailedError, ModelLoadFailedError, NoBlobFoundError, } from "../../../../utils/errors-server.js";
+import { getServerLogger } from "../../../../logging/index.js";
+const logger = getServerLogger();
 function getCorestoreDir(hyperdriveKey) {
     return path.join(getEnv().HOME_DIR, ".qvac", "corestore", hyperdriveKey);
 }
@@ -33,7 +35,7 @@ async function setupHyperdrive(hyperdriveKey, corestoreDir) {
     const swarm = new Hyperswarm(swarmOptions);
     const doneFindingPeers = drive.findingPeers();
     swarm.on("connection", (connection) => {
-        console.log(`🤝 Connected to peer for hyperdrive download`);
+        logger.debug(`🤝 Connected to peer for hyperdrive download`);
         drive.replicate(connection);
     });
     swarm.join(drive.discoveryKey, { server: false, client: true });
@@ -41,7 +43,7 @@ async function setupHyperdrive(hyperdriveKey, corestoreDir) {
     return { corestore, drive, swarm, corestoreDir };
 }
 async function cleanupHyperdrive(setup) {
-    console.log("🧹 Cleaning up hyperdrive setup");
+    logger.debug("🧹 Cleaning up hyperdrive setup");
     if (!setup.swarm.suspended) {
         try {
             await setup.swarm.suspend();
@@ -55,12 +57,12 @@ async function cleanupHyperdrive(setup) {
     await setup.corestore.close();
 }
 export async function deleteCorestoreDirectory(corestoreDir) {
-    console.log(`🗑️ DELETING corestore directory... ${corestoreDir}`);
+    logger.info(`🗑️ 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)}`);
+        logger.error(`Error deleting corestore directory: ${e instanceof Error ? e.message : String(e)}`);
     }
 }
 async function findFileInHyperdrive(drive, modelFileName) {
@@ -148,7 +150,7 @@ async function validateCachedFile(modelPath, modelFileName, expectedSize, expect
         // 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}`);
+            logger.info(`✅ Model cached with correct size: ${modelPath}`);
             // Always validate checksum if provided, even when size matches
             if (expectedChecksum && expectedChecksum.length === 64) {
                 const checksum = await calculateFileChecksum(modelPath);
@@ -156,7 +158,7 @@ async function validateCachedFile(modelPath, modelFileName, expectedSize, expect
                     throw new ChecksumValidationFailedError(`${modelFileName}. Expected: ${expectedChecksum}. Actual: ${checksum}. File may be corrupted`);
                 }
             }
-            console.log(`✅ Model already cached and size validated: ${modelPath}`);
+            logger.info(`✅ Model already cached and size validated: ${modelPath}`);
             return modelPath;
         }
         // File exists but incomplete - will be overwritten during download
@@ -173,10 +175,10 @@ async function downloadSingleFileToFilesystem(modelPath, modelFileName, hyperdri
     if (signal?.aborted) {
         throw new DownloadCancelledError();
     }
-    console.log(`Downloading model from hyperdrive ${hyperdriveKey} to ${modelPath}`);
+    logger.info(`Downloading model from hyperdrive ${hyperdriveKey} to ${modelPath}`);
     const setup = await setupHyperdrive(hyperdriveKey, corestoreDir);
     const cleanup = () => {
-        console.log("🛑 Aborting hyperdrive download...");
+        logger.info("🛑 Aborting hyperdrive download...");
         setup.swarm.suspended = true;
         setup.swarm.suspend().catch(() => {
             // Ignore errors during emergency suspend
@@ -192,7 +194,7 @@ async function downloadSingleFileToFilesystem(modelPath, modelFileName, hyperdri
             : undefined;
         await downloadAndValidateFile(setup.drive, modelFileName, modelPath, 0, // Size will be determined from drive
         expectedChecksum, progressContext, signal);
-        console.log(`✅ Model downloaded successfully to ${modelPath}`);
+        logger.info(`✅ Model downloaded successfully to ${modelPath}`);
         // Send final 100% progress update
         if (progressCallback) {
             try {
@@ -215,7 +217,7 @@ async function downloadSingleFileToFilesystem(modelPath, modelFileName, hyperdri
         }
     }
     catch (error) {
-        console.error("❌ Error during hyperdrive download:", error instanceof Error ? error.message : String(error));
+        logger.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;
@@ -263,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) {
@@ -319,7 +321,7 @@ async function downloadAndValidateFile(drive, sourceFileName, targetFilePath, ex
             }
         }
         else if (!expectedChecksum) {
-            console.log(`⚠️  No checksum available for validation`);
+            logger.warn(`⚠️  No checksum available for validation`);
         }
     }
     catch (error) {
@@ -368,11 +370,11 @@ async function downloadShardedFilesToFilesystem(hyperdriveKey, firstShardFileNam
     const shardDir = getShardedModelCacheDir(hyperdriveKey);
     const allFiles = shardMetadata.map((s) => s.filename);
     const numberedShardCount = shardInfo.totalShards;
-    console.log(`Downloading sharded model with ${numberedShardCount} numbered shards + ${allFiles.length - numberedShardCount} companion files to ${shardDir}`);
+    logger.info(`Downloading sharded model with ${numberedShardCount} numbered shards + ${allFiles.length - numberedShardCount} companion files to ${shardDir}`);
     // Check which files need to be downloaded
     const invalidIndices = await checkShardCompleteness(hyperdriveKey, allFiles, shardMetadata);
     if (invalidIndices.length === 0) {
-        console.log(`✅ All ${allFiles.length} files already downloaded and validated`);
+        logger.info(`✅ All ${allFiles.length} files already downloaded and validated`);
         if (progressCallback) {
             const overallTotal = shardMetadata.reduce((sum, shard) => sum + shard.expectedSize, 0);
             const lastFile = allFiles[allFiles.length - 1];
@@ -392,14 +394,15 @@ async function downloadShardedFilesToFilesystem(hyperdriveKey, firstShardFileNam
                 },
             });
         }
+        await extractTensorsFromShards(shardDir, firstShardFileName);
         return getShardPath(hyperdriveKey, allFiles[0]);
     }
-    console.log(`📥 Need to download ${invalidIndices.length} of ${allFiles.length} files`);
+    logger.info(`📥 Need to download ${invalidIndices.length} of ${allFiles.length} files`);
     // Setup hyperdrive once for all shards
     const corestoreDir = getCorestoreDir(hyperdriveKey);
     const setup = await setupHyperdrive(hyperdriveKey, corestoreDir);
     const cleanup = () => {
-        console.log("🛑 Aborting sharded hyperdrive download...");
+        logger.info("🛑 Aborting sharded hyperdrive download...");
         setup.swarm.suspended = true;
         setup.swarm.suspend().catch(() => {
             // Ignore errors during emergency suspend
@@ -420,7 +423,7 @@ async function downloadShardedFilesToFilesystem(hyperdriveKey, firstShardFileNam
             const filePath = getShardPath(hyperdriveKey, file);
             // Skip if already valid
             if (!invalidIndices.includes(i)) {
-                console.log(`✅ File ${i + 1}/${allFiles.length} already valid: ${file}`);
+                logger.debug(`✅ File ${i + 1}/${allFiles.length} already valid: ${file}`);
                 overallDownloaded += fileMeta.expectedSize;
                 // Report progress for skipped files
                 if (progressCallback) {
@@ -436,13 +439,13 @@ async function downloadShardedFilesToFilesystem(hyperdriveKey, firstShardFileNam
                             shardName: file,
                             overallDownloaded,
                             overallTotal,
-                            overallPercentage: overallTotal > 0 ? (overallDownloaded / overallTotal) * 100 : 0,
+                            overallPercentage: calculatePercentage(overallDownloaded, overallTotal),
                         },
                     });
                 }
                 continue;
             }
-            console.log(`📥 Downloading file ${i + 1}/${allFiles.length}: ${file}`);
+            logger.info(`📥 Downloading file ${i + 1}/${allFiles.length}: ${file}`);
             const progressContext = progressCallback
                 ? {
                     downloadKey: createHyperdriveDownloadKey(hyperdriveKey, firstShardFileName),
@@ -460,7 +463,7 @@ async function downloadShardedFilesToFilesystem(hyperdriveKey, firstShardFileNam
             if (signal?.aborted) {
                 throw new DownloadCancelledError();
             }
-            console.log(`✅ File ${i + 1}/${allFiles.length} downloaded and validated`);
+            logger.info(`✅ File ${i + 1}/${allFiles.length} downloaded and validated`);
             overallDownloaded += fileMeta.expectedSize;
         }
         if (progressCallback && overallDownloaded === overallTotal) {
@@ -481,13 +484,14 @@ async function downloadShardedFilesToFilesystem(hyperdriveKey, firstShardFileNam
                 },
             });
         }
+        await extractTensorsFromShards(shardDir, firstShardFileName);
         // Delete corestore directory after successful download (only when not seeding)
         if (!seed) {
             await deleteCorestoreDirectory(corestoreDir);
         }
     }
     catch (error) {
-        console.error("❌ Error during sharded hyperdrive download:", error instanceof Error ? error.message : String(error));
+        logger.error("❌ Error during sharded hyperdrive download:", error instanceof Error ? error.message : String(error));
         // Preserve cancellation errors
         if (error instanceof Error && error.message === "Download cancelled") {
             throw error;

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,11 +1,17 @@
 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";
 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
  */
@@ -20,14 +26,30 @@ async function resolveLocalOrCachedFile(modelIdOrPath) {
     const cachedPath = path.join(cacheDir, modelIdOrPath);
     try {
         await fsPromises.access(cachedPath);
-        console.log(`Loading cached model: ${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 {
         // Try as local file in current directory
         try {
             await fsPromises.access(modelIdOrPath);
-            console.log(`Loading local file: ${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 {
@@ -57,18 +79,27 @@ export async function resolveModelPath(modelSrc, progressCallback, seed) {
     // Check if it's an HTTP/HTTPS URL
     if (actualModelSrc.startsWith("http://") ||
         actualModelSrc.startsWith("https://")) {
-        console.log(`Loading from HTTP URL: ${actualModelSrc}`);
+        logger.info(`Loading from HTTP URL: ${actualModelSrc}`);
         actualPath = await downloadModelFromHttp(actualModelSrc, progressCallback);
-        console.log(`Loaded Model to ${actualPath}`);
+        logger.info(`Loaded Model to ${actualPath}`);
     }
     else if (hyperdriveKey) {
         // Direct hyperdrive loading
-        console.log(`Loading from hyperdrive: ${hyperdriveKey}`);
+        logger.info(`Loading from hyperdrive: ${hyperdriveKey}`);
         actualPath = await downloadModelFromHyperdrive(hyperdriveKey, actualModelSrc, seed, progressCallback);
     }
     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.d.ts

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

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

@@ -4,23 +4,28 @@ import { getRPC } from "../../bare/delegate-rpc-client.js";
 import { send, stream } from "../../../client/rpc/rpc-client.js";
 import { handleLoadModel } from "./load-model/index.js";
 import { ModelLoadFailedError, DelegateNoFinalResponseError, } from "../../../utils/errors-server.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 export async function handleLoadModelDelegated(request, progressCallback) {
     if (!request.delegate) {
         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 {
-        console.log(`📤 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;
         let finalResponse;
         if (request.withProgress) {
             // Use streaming for progress updates
-            console.log("📊 Using streaming mode for loadModel with progress");
+            logger.debug("📊 Using streaming mode for loadModel with progress");
             const responseStream = stream(providerRequest, rpc, timeout ? { timeout } : {});
             for await (const response of responseStream) {
                 if (response.type === "modelProgress") {
@@ -40,11 +45,11 @@ export async function handleLoadModelDelegated(request, progressCallback) {
         }
         else {
             // Use simple send for non-progress requests
-            console.log("📤 Using simple send mode for loadModel");
+            logger.debug("📤 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);
+            logger.error("Provider failed to load model:", finalResponse?.error);
             return {
                 type: "loadModel",
                 success: false,
@@ -62,7 +67,7 @@ export async function handleLoadModelDelegated(request, progressCallback) {
             delegateOptions.timeout = timeout;
         }
         registerModel(modelId, delegateOptions);
-        console.log(`✅ Delegated model registered: ${modelId} -> provider: ${providerPublicKey}`);
+        logger.info(`✅ Delegated model registered: ${modelId} -> provider: ${providerPublicKey}`);
         return {
             type: "loadModel",
             success: true,
@@ -70,16 +75,16 @@ export async function handleLoadModelDelegated(request, progressCallback) {
         };
     }
     catch (error) {
-        console.error("Error in delegated load model:", error);
+        logger.error("Error in delegated load model:", error);
         if (fallbackToLocal) {
-            console.log("🔄 Fallback to local model loading enabled, attempting local load...");
+            logger.info("🔄 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);
+                logger.error("❌ Local fallback also failed:", localError);
                 return {
                     type: "loadModel",
                     success: false,

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

@@ -1,12 +1,12 @@
 import { registerLoggingStream, unregisterLoggingStream, } from "../../bare/registry/logging-stream-registry.js";
 export async function* handleLoggingStream(request) {
-    const { modelId } = request;
+    const { id } = request;
     const logQueue = [];
     let pendingResolve = null;
     const streamHandler = (level, namespace, message) => {
         const logResponse = {
             type: "loggingStream",
-            modelId,
+            id,
             level: level,
             namespace,
             message,
@@ -19,7 +19,7 @@ export async function* handleLoggingStream(request) {
             resolve();
         }
     };
-    registerLoggingStream(modelId, streamHandler);
+    registerLoggingStream(id, streamHandler);
     try {
         while (true) {
             while (logQueue.length > 0) {
@@ -32,6 +32,6 @@ export async function* handleLoggingStream(request) {
         }
     }
     finally {
-        unregisterLoggingStream(modelId, streamHandler);
+        unregisterLoggingStream(id, streamHandler);
     }
 }

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",
+        };
+    }
+}

package/dist/server/rpc/handlers/provideHandler/connection.js

@@ -1,25 +1,27 @@
 import RPC from "bare-rpc";
 import { createRpcProxy } from "./proxy.js";
+import { getServerLogger } from "../../../../logging/index.js";
+const logger = getServerLogger();
 export function setupConnectionHandlers(swarm) {
-    console.log("👂 Setting up connection listener...");
+    logger.debug("👂 Setting up connection listener...");
     swarm.on("close", () => {
-        console.log("🔗 Connection closed!");
+        logger.debug("🔗 Connection closed!");
     });
     swarm.on("connection", (conn) => {
-        console.log("🔗 Connection event triggered!");
+        logger.debug("🔗 Connection event triggered!");
         const peerPubkey = conn.remotePublicKey?.toString("hex");
-        console.log(`📡 New connection established from: ${peerPubkey?.substring(0, 16)}...`);
-        console.log("🔐 Full peer public key:", peerPubkey);
+        logger.info(`📡 New connection established from: ${peerPubkey?.substring(0, 16)}...`);
+        logger.debug("🔐 Full peer public key:", peerPubkey);
         // Create RPC instance for this connection (as server)
-        console.log("⚙️ Creating RPC instance for connection...");
+        logger.debug("⚙️ Creating RPC instance for connection...");
         new RPC(conn, createRpcProxy());
-        console.log("✅ RPC instance created successfully");
+        logger.debug("✅ RPC instance created successfully");
         conn.on("close", () => {
-            console.log(`🔌 Connection closed for peer: ${peerPubkey?.substring(0, 16)}`);
+            logger.debug(`🔌 Connection closed for peer: ${peerPubkey?.substring(0, 16)}`);
         });
         conn.on("error", (err) => {
-            console.error(`❌ Connection error for peer ${peerPubkey?.substring(0, 16)}:`, err);
+            logger.error(`❌ Connection error for peer ${peerPubkey?.substring(0, 16)}:`, err);
         });
     });
-    console.log("✅ Connection listener set up");
+    logger.debug("✅ Connection listener set up");
 }

package/dist/server/rpc/handlers/provideHandler/handler.js

@@ -1,51 +1,53 @@
 import { getSwarm, registerProviderTopic } from "../../../bare/hyperswarm.js";
 import { setupConnectionHandlers } from "./connection.js";
+import { getServerLogger } from "../../../../logging/index.js";
+const logger = getServerLogger();
 export async function provideHandler(request) {
     const swarm = getSwarm({
         firewallConfig: request.firewall,
     });
-    console.log("🚀 Provide request received:", request);
-    console.log("🔍 Swarm keyPair exists:", !!swarm.keyPair);
-    console.log("🔍 Swarm publicKey:", swarm.keyPair?.publicKey?.toString("hex")?.substring(0, 16));
+    logger.debug("🚀 Provide request received:", request);
+    logger.debug("🔍 Swarm keyPair exists:", !!swarm.keyPair);
+    logger.debug("🔍 Swarm publicKey:", swarm.keyPair?.publicKey?.toString("hex")?.substring(0, 16));
     try {
-        console.log("⚡ Starting provide handler execution");
+        logger.debug("⚡ Starting provide handler execution");
         const pubKey = swarm.keyPair.publicKey;
-        console.log("🔑 Got public key:", pubKey.toString("hex"));
+        logger.debug("🔑 Got public key:", pubKey.toString("hex"));
         // Use provided topic from hex string
         const topic = Buffer.from(request.topic, "hex");
         // Join topic as server (provider)
-        console.log("🌐 Joining topic as server...");
+        logger.info("🌐 Joining topic as server...");
         const discovery = swarm.join(topic, { server: true, client: false });
-        console.log("📡 Discovery object created:", !!discovery);
+        logger.debug("📡 Discovery object created:", !!discovery);
         // Wait for the topic to be fully announced on the DHT
-        console.log("⏳ Waiting for topic announcement...");
+        logger.debug("⏳ Waiting for topic announcement...");
         await discovery.flushed();
-        console.log(`✅ Topic announced: ${topic.toString("hex")}`);
+        logger.info(`✅ Topic announced: ${topic.toString("hex")}`);
         // Wait for connections
-        console.log("⏳ Waiting for swarm flush...");
+        logger.debug("⏳ Waiting for swarm flush...");
         await swarm.flush();
-        console.log(`🎯 Ready to accept connections on topic: ${topic.toString("hex").substring(0, 16)}...`);
+        logger.info(`🎯 Ready to accept connections on topic: ${topic.toString("hex").substring(0, 16)}...`);
         // Handle incoming connections
         setupConnectionHandlers(swarm);
         registerProviderTopic(topic.toString("hex"));
-        console.log("🏁 About to return success response...");
+        logger.debug("🏁 About to return success response...");
         const response = {
             type: "provide",
             success: true,
             publicKey: pubKey.toString("hex"),
         };
-        console.log("📤 Returning response:", response);
+        logger.debug("📤 Returning response:", response);
         return response;
     }
     catch (error) {
-        console.error("❌ Error in provide handler:", error);
-        console.error("❌ Error stack:", error instanceof Error ? error.stack : "No stack trace");
+        logger.error("❌ Error in provide handler:", error);
+        logger.error("❌ Error stack:", error instanceof Error ? error.stack : "No stack trace");
         const errorResponse = {
             type: "provide",
             success: false,
             error: error instanceof Error ? error.message : "Unknown error",
         };
-        console.log("📤 Returning error response:", errorResponse);
+        logger.debug("📤 Returning error response:", errorResponse);
         return errorResponse;
     }
 }

package/dist/server/rpc/handlers/provideHandler/proxy.js

@@ -1,21 +1,23 @@
 import { handleRequest } from "../../handle-request.js";
+import { getServerLogger } from "../../../../logging/index.js";
+const logger = getServerLogger();
 // Proxies RPC requests to the main handler: handleRequest
 export function createRpcProxy() {
     return async (rpcRequest) => {
-        console.log("📬 RPC request callback triggered!");
-        console.log("📦 Raw RPC request data:", rpcRequest.data?.toString());
+        logger.debug("📬 RPC request callback triggered!");
+        logger.debug("📦 Raw RPC request data:", rpcRequest.data?.toString());
         try {
-            console.log("🚀 Calling handleRequest...");
+            logger.debug("🚀 Calling handleRequest...");
             await handleRequest(rpcRequest);
-            console.log("✅ handleRequest completed successfully");
+            logger.debug("✅ handleRequest completed successfully");
         }
         catch (error) {
-            console.error("❌ Error:", error instanceof Error ? error.message : error);
+            logger.error("❌ Error:", error instanceof Error ? error.message : error);
             const errorResponse = JSON.stringify({
                 type: "error",
                 error: error instanceof Error ? error.message : "Unknown error",
             });
-            console.log("📤 Sending error response:", errorResponse);
+            logger.debug("📤 Sending error response:", errorResponse);
             rpcRequest.reply(errorResponse, "utf-8");
         }
     };

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

@@ -1,3 +1,3 @@
-import type { RagRequest, RagResponse } from "../../../schemas/index";
-export declare function handleRag(request: RagRequest): Promise<RagResponse>;
+import type { RagRequest, RagResponse, RagProgressUpdate } from "../../../schemas/index";
+export declare function handleRag(request: RagRequest, onProgress?: (update: RagProgressUpdate) => void): Promise<RagResponse>;
 //# sourceMappingURL=rag.d.ts.map