@qvac/sdk 0.4.1 → 0.5.0

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

@@ -1,4 +1,6 @@
 import {} from "../../../../schemas/index.js";
+import { getServerLogger } from "../../../../logging/index.js";
+const logger = getServerLogger();
 const activeDownloads = new Map();
 const clearCacheFlags = new Map();
 export const getActiveDownload = (key) => activeDownloads.get(key);
@@ -33,7 +35,7 @@ export const createCancelFunction = (downloadKey, clearCache = false) => () => {
     unregisterDownload(downloadKey);
 };
 export const cancelAllDownloads = () => {
-    console.log(`🧹 Cancelling ${activeDownloads.size} active downloads`);
+    logger.info(`🧹 Cancelling ${activeDownloads.size} active downloads`);
     Array.from(activeDownloads.keys()).forEach((key) => createCancelFunction(key)());
 };
 let isCleaningUp = false;
@@ -49,6 +51,6 @@ export const cleanupDownloads = async () => {
         }
     }
     catch (error) {
-        console.error("❌ Error during download cleanup:", error);
+        logger.error("❌ Error during download cleanup:", error);
     }
 };

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

@@ -5,6 +5,8 @@ import { AbortController } from "bare-abort-controller";
 import { getModelsCacheDir, generateShortHash } from "../../../utils/index.js";
 import { getActiveDownload, registerDownload, unregisterDownload, createHttpDownloadKey, shouldClearCache, clearClearCacheFlag, } from "./download-manager.js";
 import { DownloadCancelledError, HTTPError, NoResponseBodyError, ResponseBodyNotReadableError, } from "../../../../utils/errors-server.js";
+import { getServerLogger } from "../../../../logging/index.js";
+const logger = getServerLogger();
 function extractFilenameFromUrl(url) {
     // Parse URL to get the filename from the path
     const urlParts = url.split("/");
@@ -28,14 +30,14 @@ async function validateCachedFile(modelPath, url, signal) {
             expectedSize = parseInt(response.headers.get("content-length") || "0");
         }
         catch (error) {
-            console.log(`⚠️ Could not get expected file size from HEAD request, will re-download: ${String(error)}`);
+            logger.warn(`⚠️ Could not get expected file size from HEAD request, will re-download: ${String(error)}`);
             return null;
         }
         if (localSize !== expectedSize) {
-            console.log(`📥 Cached file size mismatch. Expected: ${expectedSize}, Found: ${localSize}. Re-downloading...`);
+            logger.info(`📥 Cached file size mismatch. Expected: ${expectedSize}, Found: ${localSize}. Re-downloading...`);
             return null;
         }
-        console.log(`✅ Using cached HTTP model: ${modelPath}`);
+        logger.info(`✅ Using cached HTTP model: ${modelPath}`);
         return modelPath;
     }
     catch {
@@ -47,7 +49,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
     if (signal?.aborted) {
         throw new DownloadCancelledError();
     }
-    console.log(`📥 Downloading model from HTTP: ${url}`);
+    logger.info(`📥 Downloading model from HTTP: ${url}`);
     // Check if file exists for resuming
     let startOffset = 0;
     let downloadedBytes = 0;
@@ -55,10 +57,10 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
         const existingStats = await fsPromises.stat(modelPath);
         startOffset = existingStats.size;
         downloadedBytes = startOffset;
-        console.log(`📥 Resuming download from byte ${startOffset}`);
+        logger.info(`📥 Resuming download from byte ${startOffset}`);
     }
     catch {
-        console.log(`📥 Starting fresh download`);
+        logger.info(`📥 Starting fresh download`);
     }
     // Prepare headers for resume if needed
     const headers = {
@@ -77,7 +79,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
     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`);
+            logger.info(`✅ File already completely downloaded`);
             // Send 100% progress for already complete file
             if (progressCallback) {
                 progressCallback({
@@ -92,7 +94,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
         }
         // Check if server doesn't support range requests
         if (response.status === 200 && startOffset > 0) {
-            console.log(`⚠️ Server doesn't support resume, starting fresh download`);
+            logger.warn(`⚠️ Server doesn't support resume, starting fresh download`);
             startOffset = 0;
             downloadedBytes = 0;
             // Retry without Range header
@@ -131,7 +133,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
         // For fresh downloads
         totalBytes = contentLength ? parseInt(contentLength) : 0;
     }
-    console.log(`📏 Total size: ${totalBytes} bytes (${(totalBytes / 1024 / 1024).toFixed(2)} MB)`);
+    logger.info(`📏 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);
@@ -174,7 +176,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                     signal.addEventListener("abort", abortHandler);
                 }
                 writeStream.on("finish", () => {
-                    console.log(`✅ Model downloaded successfully to ${modelPath}`);
+                    logger.info(`✅ Model downloaded successfully to ${modelPath}`);
                     if (signal) {
                         signal.removeEventListener("abort", abortHandler);
                     }
@@ -216,7 +218,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
             // Close the write stream
             await new Promise((resolve, reject) => {
                 writeStream.end(() => {
-                    console.log(`✅ Model downloaded successfully to ${modelPath}`);
+                    logger.info(`✅ Model downloaded successfully to ${modelPath}`);
                     resolve();
                 });
                 writeStream.on("error", reject);
@@ -262,7 +264,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
                 // Close the write stream
                 await new Promise((resolve, reject) => {
                     writeStream.end(() => {
-                        console.log(`✅ Model downloaded successfully to ${modelPath}`);
+                        logger.info(`✅ Model downloaded successfully to ${modelPath}`);
                         resolve();
                     });
                     writeStream.on("error", reject);
@@ -275,7 +277,7 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
     }
     catch (error) {
         writeStream.destroy();
-        console.error("Error during download:", error instanceof Error ? error.message : String(error));
+        logger.error("Error during download:", error instanceof Error ? error.message : String(error));
         throw error instanceof Error ? error : new Error(String(error));
     }
 }
@@ -284,7 +286,7 @@ export async function downloadModelFromHttp(url, progressCallback) {
     // Check if already downloading
     const existing = getActiveDownload(downloadKey);
     if (existing) {
-        console.log(`📥 Reusing existing download for: ${downloadKey}`);
+        logger.info(`📥 Reusing existing download for: ${downloadKey}`);
         return existing.promise;
     }
     const cacheDir = getModelsCacheDir();
@@ -336,21 +338,21 @@ export async function downloadModelFromHttp(url, progressCallback) {
             return modelPath;
         }
         catch (error) {
-            console.error("❌ Error downloading model:", error instanceof Error ? error.message : String(error));
+            logger.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");
+                    logger.info("🗑️ Clearing cache - deleting partial file");
                     try {
                         await fsPromises.unlink(modelPath);
-                        console.log(`✅ Deleted partial file: ${modelPath}`);
+                        logger.info(`✅ Deleted partial file: ${modelPath}`);
                     }
                     catch {
                         // Ignore cleanup errors
                     }
                 }
                 else {
-                    console.log("📥 Download paused - partial file preserved for resume");
+                    logger.info("📥 Download paused - partial file preserved for resume");
                 }
                 clearClearCacheFlag(downloadKey);
             }

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

@@ -11,6 +11,8 @@ 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;
@@ -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];
@@ -394,12 +396,12 @@ async function downloadShardedFilesToFilesystem(hyperdriveKey, firstShardFileNam
         }
         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 +422,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) {
@@ -442,7 +444,7 @@ async function downloadShardedFilesToFilesystem(hyperdriveKey, firstShardFileNam
                 }
                 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 +462,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) {
@@ -487,7 +489,7 @@ async function downloadShardedFilesToFilesystem(hyperdriveKey, firstShardFileNam
         }
     }
     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/resolve.js

@@ -6,6 +6,8 @@ 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();
 /**
  * Resolves a local file path or cached file
  */
@@ -20,14 +22,14 @@ 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}`);
         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}`);
             return modelIdOrPath;
         }
         catch {
@@ -57,13 +59,13 @@ 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("\\")) {

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,6 +4,8 @@ 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");
@@ -11,7 +13,7 @@ export async function handleLoadModelDelegated(request, progressCallback) {
     const { delegate } = request;
     const { topic, providerPublicKey, timeout, fallbackToLocal } = 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` : ""}`);
         // Create RPC instance for this HyperSwarm peer
         const rpc = await getRPC(topic, providerPublicKey, { timeout });
         // Strip out the delegate field to avoid infinite delegation
@@ -20,7 +22,7 @@ export async function handleLoadModelDelegated(request, progressCallback) {
         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 +42,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 +64,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 +72,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/load-model.js

@@ -1,8 +1,16 @@
 import { loadModel } from "../../bare/addons/index.js";
 import { resolveModelPath } from "./load-model/resolve.js";
-import { generateShortHash } from "../../utils/index.js";
-import { TTSConfigModelRequiredError, ESpeakDataPathRequiredError, } from "../../../utils/errors-server.js";
+import { getModelEntry, updateModelConfig, } from "../../bare/registry/model-registry.js";
+import { generateShortHash, transformConfigForReload } from "../../utils/index.js";
+import { TTSConfigModelRequiredError, ESpeakDataPathRequiredError, ConfigReloadNotSupportedError, ModelTypeMismatchError, ModelIsDelegatedError, ModelNotFoundError, } from "../../../utils/errors-server.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 export async function handleLoadModel(request, progressCallback) {
+    // Handle reload config
+    if (isReloadConfigRequest(request)) {
+        return handleConfigReload(request);
+    }
+    // Handle load new model from source
     const { modelSrc, modelName, seed, projectionModelSrc, vadModelSrc, configSrc, } = request;
     const eSpeakDataPath = request.modelType === "tts"
         ? request.eSpeakDataPath
@@ -49,7 +57,48 @@ export async function handleLoadModel(request, progressCallback) {
         };
     }
     catch (error) {
-        console.error("Error loading model:", error);
+        logger.error("Error loading model:", error);
+        return {
+            type: "loadModel",
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}
+async function handleConfigReload(request) {
+    const { modelId, modelType, modelConfig } = request;
+    try {
+        const entry = getModelEntry(modelId);
+        if (!entry) {
+            throw new ModelNotFoundError(modelId);
+        }
+        if (entry.isDelegated) {
+            throw new ModelIsDelegatedError(modelId);
+        }
+        const storedModelType = entry.local.modelType;
+        if (storedModelType !== modelType) {
+            throw new ModelTypeMismatchError(storedModelType, modelType);
+        }
+        const model = entry.local.model;
+        const currentConfig = entry.local.config;
+        if (typeof model.reload !== "function") {
+            throw new ConfigReloadNotSupportedError(modelId);
+        }
+        const mergedConfig = {
+            ...currentConfig,
+            ...modelConfig,
+        };
+        const reloadConfig = transformConfigForReload(storedModelType, mergedConfig);
+        await model.reload(reloadConfig);
+        updateModelConfig(modelId, mergedConfig);
+        return {
+            type: "loadModel",
+            success: true,
+            modelId,
+        };
+    }
+    catch (error) {
+        logger.error("Error reloading config:", error);
         return {
             type: "loadModel",
             success: false,
@@ -57,3 +106,6 @@ export async function handleLoadModel(request, progressCallback) {
         };
     }
 }
+function isReloadConfigRequest(request) {
+    return "modelId" in request && !("modelSrc" in request);
+}

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/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");
 }