@qvac/sdk 0.8.0 → 1.0.0

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

@@ -1,5 +1,3 @@
 import { type ModelProgressUpdate } from "../../../../schemas/index";
-import type { ResolveResult } from "./types";
-export declare function resolveModelPath(modelSrc: unknown, progressCallback?: (progress: ModelProgressUpdate) => void, seed?: boolean): Promise<string>;
-export declare function resolveModelPathWithStats(modelSrc: unknown, progressCallback?: (progress: ModelProgressUpdate) => void, seed?: boolean): Promise<ResolveResult>;
+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

@@ -1,21 +1,10 @@
-import { models, getModelByPath } from "../../../../models/registry/models.js";
-import { hyperdriveUrlSchema, registryUrlSchema, SUPPORTED_ARCHIVE_EXTENSIONS, } from "../../../../schemas/index.js";
-import { getModelsCacheDir, getShardedModelCacheDir, generateShortHash, extractAndValidateShardedArchive, } from "../../../utils/index.js";
+import { 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";
-import { downloadModelFromRegistry } from "./registry.js";
-import { downloadModelFromHttpWithStats, downloadModelFromHyperdriveWithStats, downloadModelFromRegistryWithStats, } from "./download-stats.js";
-import { ModelLoadFailedError, ModelNotFoundError, SeedingNotSupportedError, } from "../../../../utils/errors-server.js";
-import { validateAndJoinPath } from "../../../utils/path-security.js";
-import { getServerLogger } from "../../../../logging/index.js";
-import { modelInputToSrcSchema } from "../../../../schemas/index.js";
-const logger = getServerLogger();
-function isArchivePath(filePath) {
-    const filename = path.basename(filePath).toLowerCase();
-    return SUPPORTED_ARCHIVE_EXTENSIONS.some((ext) => filename.endsWith(ext));
-}
 /**
  * Resolves a local file path or cached file
  */
@@ -23,133 +12,63 @@ 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 ModelLoadFailedError(`Direct hyperdrive keys not supported. Use hyperdriveKey parameter instead. Example: loadModel("model.gguf", "${modelIdOrPath}")`);
+        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 = validateAndJoinPath(cacheDir, modelIdOrPath);
+    const cachedPath = path.join(cacheDir, modelIdOrPath);
     try {
         await fsPromises.access(cachedPath);
-        logger.info(`Loading cached model: ${cachedPath}`);
-        // Check if cached file is an archive
-        if (isArchivePath(cachedPath)) {
-            logger.info(`Extracting cached archive: ${cachedPath}`);
-            const archiveHash = generateShortHash(cachedPath);
-            const extractDir = getShardedModelCacheDir(archiveHash);
-            const extractedPath = await extractAndValidateShardedArchive(cachedPath, extractDir);
-            return extractedPath;
-        }
+        console.log(`Loading cached model: ${cachedPath}`);
         return cachedPath;
     }
     catch {
         // Try as local file in current directory
         try {
             await fsPromises.access(modelIdOrPath);
-            logger.info(`Loading local file: ${modelIdOrPath}`);
-            // Check if local file is an archive
-            if (isArchivePath(modelIdOrPath)) {
-                logger.info(`Extracting local archive: ${modelIdOrPath}`);
-                const archiveHash = generateShortHash(modelIdOrPath);
-                const extractDir = getShardedModelCacheDir(archiveHash);
-                const extractedPath = await extractAndValidateShardedArchive(modelIdOrPath, extractDir);
-                return extractedPath;
-            }
+            console.log(`Loading local file: ${modelIdOrPath}`);
             return modelIdOrPath;
         }
         catch {
             // Invalid model ID - provide helpful error
             const availableModels = models.map((m) => m.modelId);
-            throw new ModelNotFoundError(`${modelIdOrPath}". Available models: ${availableModels.join(", ")}`);
+            throw new Error(`Invalid model ID: "${modelIdOrPath}". Available models: ${availableModels.join(", ")}`);
         }
     }
 }
-function selectDownloaders(mode) {
-    if (mode === "stats") {
-        return {
-            http: downloadModelFromHttpWithStats,
-            registry: downloadModelFromRegistryWithStats,
-            hyperdrive: downloadModelFromHyperdriveWithStats,
-        };
-    }
-    return {
-        http: downloadModelFromHttp,
-        registry: downloadModelFromRegistry,
-        hyperdrive: downloadModelFromHyperdrive,
-    };
-}
-function isDownloadResult(value) {
-    return value !== null && typeof value === "object" && "path" in value;
-}
-function buildResult(pathOrResult, sourceType) {
-    if (isDownloadResult(pathOrResult)) {
-        return pathOrResult.stats
-            ? { path: pathOrResult.path, sourceType, downloadStats: pathOrResult.stats }
-            : { path: pathOrResult.path, sourceType };
-    }
-    return { path: pathOrResult, sourceType };
-}
-async function resolveModelPathCore(modelSrc, progressCallback, seed, mode) {
-    const srcString = modelInputToSrcSchema.parse(modelSrc);
-    const downloaders = selectDownloaders(mode);
+export async function resolveModelPath(modelSrc, progressCallback, seed) {
     // Parse hyperdrive URLs if present
     let hyperdriveKey;
-    let actualModelSrc = srcString;
-    if (srcString.startsWith("pear://")) {
-        const { key, path: pathValue } = hyperdriveUrlSchema.parse(srcString);
+    let actualModelSrc = modelSrc;
+    if (modelSrc.startsWith("pear://")) {
+        const { key, path } = hyperdriveUrlSchema.parse(modelSrc);
         hyperdriveKey = key;
-        actualModelSrc = pathValue;
-    }
-    // Registry source
-    if (srcString.startsWith("registry://")) {
-        const { registryPath, registrySource } = registryUrlSchema.parse(srcString);
-        logger.info(`Loading from registry: ${registryPath}`);
-        // Look up model metadata for checksum validation
-        const modelMetadata = getModelByPath(registryPath);
-        const expectedChecksum = modelMetadata?.sha256Checksum;
-        const result = await downloaders.registry(registryPath, registrySource, progressCallback, expectedChecksum);
-        logger.info(`Loaded Model to ${isDownloadResult(result) ? result.path : result}`);
-        return buildResult(result, "registry");
+        actualModelSrc = path;
     }
+    let actualPath;
     // Validate seeding is only used with hyperdrive models
     if (seed && !hyperdriveKey) {
-        throw new SeedingNotSupportedError();
+        throw new Error("Seeding is only supported for hyperdrive models");
     }
-    // HTTP source
+    // Check if it's an HTTP/HTTPS URL
     if (actualModelSrc.startsWith("http://") ||
         actualModelSrc.startsWith("https://")) {
-        logger.info(`Loading from HTTP URL: ${actualModelSrc}`);
-        const result = await downloaders.http(actualModelSrc, progressCallback);
-        logger.info(`Loaded Model to ${isDownloadResult(result) ? result.path : result}`);
-        return buildResult(result, "http");
+        console.log(`Loading from HTTP URL: ${actualModelSrc}`);
+        actualPath = await downloadModelFromHttp(actualModelSrc, progressCallback);
+        console.log(`Loaded Model to ${actualPath}`);
     }
-    // Hyperdrive source
-    if (hyperdriveKey) {
-        logger.info(`Loading from hyperdrive: ${hyperdriveKey}`);
-        const result = await downloaders.hyperdrive(hyperdriveKey, actualModelSrc, seed, progressCallback);
-        return buildResult(result, "hyperdrive");
+    else if (hyperdriveKey) {
+        // Direct hyperdrive loading
+        console.log(`Loading from hyperdrive: ${hyperdriveKey}`);
+        actualPath = await downloadModelFromHyperdrive(hyperdriveKey, actualModelSrc, seed, progressCallback);
     }
-    // Filesystem source (local files, cached files)
-    let resolvedPath;
-    if (actualModelSrc.includes("/") || actualModelSrc.includes("\\")) {
-        if (isArchivePath(actualModelSrc)) {
-            logger.info(`Extracting local archive: ${actualModelSrc}`);
-            const archiveHash = generateShortHash(actualModelSrc);
-            const extractDir = getShardedModelCacheDir(archiveHash);
-            resolvedPath = await extractAndValidateShardedArchive(actualModelSrc, extractDir);
-        }
-        else {
-            resolvedPath = actualModelSrc;
-        }
+    else if (actualModelSrc.includes("/") || actualModelSrc.includes("\\")) {
+        // Handle file paths (absolute or relative with slashes)
+        actualPath = actualModelSrc;
     }
     else {
-        resolvedPath = await resolveLocalOrCachedFile(actualModelSrc);
+        // Handle local files and cached files
+        actualPath = await resolveLocalOrCachedFile(actualModelSrc);
     }
-    return { path: resolvedPath, sourceType: "filesystem" };
-}
-export async function resolveModelPath(modelSrc, progressCallback, seed) {
-    const result = await resolveModelPathCore(modelSrc, progressCallback, seed, "base");
-    return result.path;
-}
-export async function resolveModelPathWithStats(modelSrc, progressCallback, seed) {
-    return resolveModelPathCore(modelSrc, progressCallback, seed, "stats");
+    return actualPath;
 }

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

@@ -1,7 +1,3 @@
-import type { LoadModelSrcRequest, LoadModelResponse, ModelProgressUpdate } from "../../../schemas/index";
-import type { DelegatedHandlerOptions } from "../profiling/index";
-export interface HandleLoadModelDelegatedOptions extends DelegatedHandlerOptions {
-    progressCallback?: (update: ModelProgressUpdate) => void;
-}
-export declare function handleLoadModelDelegated(request: LoadModelSrcRequest, options?: HandleLoadModelDelegatedOptions): Promise<LoadModelResponse>;
+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

@@ -1,43 +1,25 @@
-import { DELEGATION_BREAKDOWN_KEY, OPERATION_EVENT_KEY, modelInputToSrcSchema } from "../../../schemas/index.js";
-import { registerModel, isModelLoaded, unregisterModel } from "../../bare/registry/model-registry.js";
-import { send, stream, } from "../delegate-transport.js";
-import { getRPC, cleanupStaleConnection, } from "../../bare/delegate-rpc-client.js";
+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";
-import { ModelLoadFailedError, DelegateNoFinalResponseError, } from "../../../utils/errors-server.js";
-import { getServerLogger } from "../../../logging/index.js";
-const logger = getServerLogger();
-export async function handleLoadModelDelegated(request, options) {
-    const { progressCallback, profilingMeta } = options ?? {};
+export async function handleLoadModelDelegated(request, progressCallback) {
     if (!request.delegate) {
-        throw new ModelLoadFailedError("Delegate information is required for delegated load model");
+        throw new Error("Delegate information is required for delegated load model");
     }
     const { delegate } = request;
-    const { topic, providerPublicKey, timeout, fallbackToLocal, forceNewConnection, } = delegate;
+    const { topic, providerPublicKey, timeout, fallbackToLocal } = delegate;
     try {
-        logger.info(`📤 Sending delegated loadModel request to provider: ${providerPublicKey}${timeout ? `, timeout: ${timeout}ms` : ""}${forceNewConnection ? " (forcing new connection)" : ""}`);
+        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,
-            forceNewConnection,
-        });
+        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;
-        let delegationBreakdown;
-        let operationEvent;
-        // Build delegate options with profiling metadata
-        const delegateOpts = { peerKey: providerPublicKey };
-        if (profilingMeta) {
-            delegateOpts.profilingMeta = profilingMeta;
-        }
-        if (timeout) {
-            delegateOpts.timeout = timeout;
-        }
         if (request.withProgress) {
             // Use streaming for progress updates
-            logger.debug("📊 Using streaming mode for loadModel with progress");
-            const responseStream = stream(providerRequest, rpc, delegateOpts);
+            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
@@ -47,34 +29,28 @@ export async function handleLoadModelDelegated(request, options) {
                 }
                 else if (response.type === "loadModel") {
                     finalResponse = response;
-                    operationEvent = response[OPERATION_EVENT_KEY];
                     break;
                 }
             }
             if (!finalResponse) {
-                throw new DelegateNoFinalResponseError();
+                throw new Error("No final response received from provider");
             }
         }
         else {
             // Use simple send for non-progress requests
-            logger.debug("📤 Using simple send mode for loadModel");
-            const providerResponse = await send(providerRequest, rpc, delegateOpts);
-            finalResponse = providerResponse;
-            const typedResponse = providerResponse;
-            delegationBreakdown = typedResponse[DELEGATION_BREAKDOWN_KEY];
-            operationEvent = typedResponse[OPERATION_EVENT_KEY];
+            console.log("📤 Using simple send mode for loadModel");
+            finalResponse = (await send(providerRequest, rpc, timeout ? { timeout } : {}));
         }
         if (!finalResponse || !finalResponse.success) {
-            logger.error("Provider failed to load model:", finalResponse?.error);
+            console.error("Provider failed to load model:", finalResponse?.error);
             return {
                 type: "loadModel",
                 success: false,
                 error: `Provider failed to load model: ${finalResponse?.error || "Unknown error"}`,
             };
         }
-        const modelId = finalResponse.modelId ||
-            modelInputToSrcSchema.parse(request.modelSrc) ||
-            `delegated-${Date.now()}`;
+        // Register the delegated model with provider info
+        const modelId = finalResponse.modelId || request.modelSrc || `delegated-${Date.now()}`;
         const delegateOptions = {
             topic,
             providerPublicKey,
@@ -82,39 +58,25 @@ export async function handleLoadModelDelegated(request, options) {
         if (timeout !== undefined) {
             delegateOptions.timeout = timeout;
         }
-        if (isModelLoaded(modelId)) {
-            logger.info(`Delegated model ${modelId} is already registered, replacing with new provider: ${providerPublicKey}`);
-            unregisterModel(modelId);
-        }
         registerModel(modelId, delegateOptions);
-        logger.info(`✅ Delegated model registered: ${modelId} -> provider: ${providerPublicKey}`);
-        const result = {
+        console.log(`✅ Delegated model registered: ${modelId} -> provider: ${providerPublicKey}`);
+        return {
             type: "loadModel",
             success: true,
             modelId,
         };
-        if (delegationBreakdown) {
-            result[DELEGATION_BREAKDOWN_KEY] =
-                delegationBreakdown;
-        }
-        if (operationEvent) {
-            result[OPERATION_EVENT_KEY] = operationEvent;
-        }
-        return result;
     }
     catch (error) {
-        logger.error("Error in delegated load model:", error);
-        // Clean up stale RPC so next attempt creates a fresh connection
-        cleanupStaleConnection(providerPublicKey);
+        console.error("Error in delegated load model:", error);
         if (fallbackToLocal) {
-            logger.info("🔄 Fallback to local model loading enabled, attempting local load...");
+            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) {
-                logger.error("❌ Local fallback also failed:", localError);
+                console.error("❌ Local fallback also failed:", localError);
                 return {
                     type: "loadModel",
                     success: false,

package/dist/server/rpc/handlers/{load-model/handler.d.ts → load-model.d.ts}

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

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

@@ -0,0 +1,57 @@
+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, configSrc } = request;
+    const eSpeakDataPath = request.modelType === "tts"
+        ? request.eSpeakDataPath
+        : undefined;
+    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);
+        }
+        let ttsConfigModelPath;
+        if (configSrc) {
+            ttsConfigModelPath = await resolveModelPath(configSrc, progressCallback, seed);
+        }
+        // For TTS models, ttsConfigModelPath and eSpeakDataPath are required
+        if (request.modelType === "tts" && !ttsConfigModelPath) {
+            throw new Error("ttsConfigModelPath is required for TTS models");
+        }
+        if (request.modelType === "tts" && !eSpeakDataPath) {
+            throw new Error("eSpeakDataPath is required for TTS models");
+        }
+        // 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,
+            ttsConfigModelPath,
+            eSpeakDataPath,
+        });
+        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.js

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

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

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

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

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

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

@@ -1,23 +1,21 @@
 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) => {
-        logger.debug("📬 RPC request callback triggered!");
-        logger.debug("📦 Raw RPC request data:", rpcRequest.data?.toString());
+        console.log("📬 RPC request callback triggered!");
+        console.log("📦 Raw RPC request data:", rpcRequest.data?.toString());
         try {
-            logger.debug("🚀 Calling handleRequest...");
+            console.log("🚀 Calling handleRequest...");
             await handleRequest(rpcRequest);
-            logger.debug("✅ handleRequest completed successfully");
+            console.log("✅ handleRequest completed successfully");
         }
         catch (error) {
-            logger.error("❌ Error:", error instanceof Error ? error.message : error);
+            console.error("❌ Error:", error instanceof Error ? error.message : error);
             const errorResponse = JSON.stringify({
                 type: "error",
                 error: error instanceof Error ? error.message : "Unknown error",
             });
-            logger.debug("📤 Sending error response:", errorResponse);
+            console.log("📤 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, RagProgressUpdate } from "../../../schemas/index";
-export declare function handleRag(request: RagRequest, onProgress?: (update: RagProgressUpdate) => void): Promise<RagResponse>;
+import type { RagRequest, RagResponse } from "../../../schemas/index";
+export declare function handleRag(request: RagRequest): Promise<RagResponse>;
 //# sourceMappingURL=rag.d.ts.map