@qvac/sdk 0.4.1 → 0.6.0

package/dist/client/rpc/bare-client.js

@@ -1,20 +1,43 @@
+import { normalizeModelType } from "../../schemas/index.js";
+import os from "bare-os";
 import { handlers } from "../../server/rpc/handlers/index.js";
 import { RPCNoHandlerError, RPCRequestNotSentError, } from "../../utils/errors-client.js";
+import { initializeConfig } from "../init-hooks.js";
+import { setSDKConfig } from "../../server/bare/registry/config-registry.js";
+import { setRuntimeContext } from "../../server/bare/registry/runtime-context-registry.js";
+import { resolveModelConfig } from "../../server/bare/registry/model-config-registry.js";
+import { resolveConfig } from "../config-loader/resolve-config.bare.js";
 // Get the handler for a request type
-const getHandler = (type) => {
+function getHandler(type) {
     const handler = handlers[type];
     return typeof handler === "function" ? handler : undefined;
-};
-export async function send(request) {
+}
+function applyDeviceDefaultsToLoadModel(request) {
+    if (request.type !== "loadModel" || !("modelSrc" in request)) {
+        return request;
+    }
+    let canonicalType;
+    try {
+        canonicalType = normalizeModelType(request.modelType);
+    }
+    catch {
+        return request;
+    }
+    const rawConfig = request.modelConfig ?? {};
+    const configWithDefaults = resolveModelConfig(canonicalType, rawConfig);
+    return { ...request, modelConfig: configWithDefaults };
+}
+async function send(request) {
     if (request.type === "ping") {
         return { type: "pong", number: Math.random() * 100 };
     }
     const handler = getHandler(request.type);
     if (!handler)
         throw new RPCNoHandlerError(request.type);
-    return (await handler(request));
+    const processedRequest = applyDeviceDefaultsToLoadModel(request);
+    return (await handler(processedRequest));
 }
-export async function* stream(request) {
+async function* stream(request) {
     const handler = getHandler(request.type);
     if (!handler)
         throw new RPCNoHandlerError(request.type);
@@ -22,11 +45,12 @@ export async function* stream(request) {
     if (request.type === "loadModel" &&
         "withProgress" in request &&
         request.withProgress) {
+        const processedRequest = applyDeviceDefaultsToLoadModel(request);
         async function* streamWithProgress() {
             const queue = [];
             let done = false;
             const loadModelHandler = handler;
-            loadModelHandler(request, (update) => queue.push(update))
+            loadModelHandler(processedRequest, (update) => queue.push(update))
                 .then((final) => {
                 queue.push(final);
                 done = true;
@@ -97,6 +121,27 @@ const createMockRPCRequest = () => {
             if (!requestData) {
                 throw new RPCRequestNotSentError();
             }
+            // Handle special internal config initialization message
+            if (typeof requestData === "object" &&
+                "type" in requestData &&
+                requestData.type === "__init_config") {
+                try {
+                    const initData = requestData;
+                    if (initData.config) {
+                        setSDKConfig(initData.config);
+                    }
+                    if (initData.runtimeContext) {
+                        setRuntimeContext(initData.runtimeContext);
+                    }
+                    return Buffer.from(JSON.stringify({ success: true }));
+                }
+                catch (error) {
+                    return Buffer.from(JSON.stringify({
+                        success: false,
+                        error: error instanceof Error ? error.message : String(error),
+                    }));
+                }
+            }
             const response = await send(requestData);
             return Buffer.from(JSON.stringify(response));
         },
@@ -110,10 +155,24 @@ const createMockRPCRequest = () => {
         },
     };
 };
-export function getRPC() {
-    return {
+let configInitialized = false;
+export async function getRPC() {
+    const mockRPC = {
         request() {
             return createMockRPCRequest();
         },
     };
+    // Initialize config once on first call
+    if (!configInitialized) {
+        const runtimeContext = {
+            runtime: "bare",
+            platform: os.platform(),
+        };
+        await initializeConfig(mockRPC, resolveConfig, runtimeContext);
+        configInitialized = true;
+    }
+    return mockRPC;
+}
+export function close() {
+    // noop
 }

package/dist/client/rpc/expo-rpc-client.d.ts

@@ -1,4 +1,4 @@
 import RPC from "bare-rpc";
-export declare const getRPC: () => Promise<RPC>;
-export declare const close: () => void;
+export declare function getRPC(): Promise<RPC>;
+export declare function close(): void;
 //# sourceMappingURL=expo-rpc-client.d.ts.map

package/dist/client/rpc/expo-rpc-client.js

@@ -1,9 +1,54 @@
 import RPC from "bare-rpc";
 import { RPCConnectionFailedError } from "../../utils/errors-client.js";
+import { initializeConfig } from "../init-hooks.js";
+import { resolveConfig } from "../config-loader/resolve-config.expo.js";
+import { getClientLogger } from "../../logging/index.js";
+const logger = getClientLogger();
 let rpcInstance = null;
 let rpcPromise = null;
-console.log("EXPO RPC Client bundle");
-export const getRPC = async () => {
+let workletInstance = null;
+let workletInitialized = false;
+let cachedRuntimeContext;
+logger.debug("EXPO RPC Client bundle");
+async function getRuntimeContext() {
+    if (cachedRuntimeContext) {
+        return cachedRuntimeContext;
+    }
+    // expo-device is optional - gracefully handle if not installed
+    let deviceModel;
+    let deviceBrand;
+    let platform;
+    try {
+        const expoModulesCore = await import("expo-modules-core");
+        // this looks odd, but is necessary to ensure that import can be used safely.
+        // It will crash the app if the module is not installed, but the node dependency is present.
+        const nativeDeviceModule = expoModulesCore.requireOptionalNativeModule("ExpoDevice");
+        if (nativeDeviceModule) {
+            const Device = await import("expo-device");
+            logger.info(`Device: ${Device.modelName} ${Device.brand} ${Device.osName}`);
+            const osName = Device?.osName?.toLowerCase();
+            if (osName?.includes("ios")) {
+                platform = "ios";
+            }
+            else if (osName?.includes("android")) {
+                platform = "android";
+            }
+            deviceModel = Device.modelName ?? undefined;
+            deviceBrand = Device.brand ?? undefined;
+        }
+    }
+    catch {
+        logger.debug("expo-device not available, device info will be omitted");
+    }
+    cachedRuntimeContext = {
+        runtime: "react-native",
+        platform,
+        deviceModel,
+        deviceBrand,
+    };
+    return cachedRuntimeContext;
+}
+export async function getRPC() {
     if (rpcInstance) {
         return rpcInstance;
     }
@@ -11,10 +56,22 @@ export const getRPC = async () => {
         return rpcPromise;
     }
     rpcPromise = (async () => {
+        if (workletInstance) {
+            logger.debug("🔄 Reusing existing worklet");
+            rpcInstance = new RPC(workletInstance.IPC, () => { });
+            // Only initialize once per worklet - server state persists
+            if (!workletInitialized) {
+                const runtimeContext = await getRuntimeContext();
+                await initializeConfig(rpcInstance, resolveConfig, runtimeContext);
+                workletInitialized = true;
+            }
+            return rpcInstance;
+        }
         const { Paths } = await import("expo-file-system");
         const bareKitModule = await import("react-native-bare-kit");
         const worklet = new bareKitModule.Worklet();
-        console.log("Starting worklet");
+        workletInstance = worklet;
+        logger.debug("Starting new worklet");
         // Load the mobile bundle - this will be generated by the Expo plugin
         // using the user's installed bare library versions
         let mobileBundle;
@@ -28,7 +85,7 @@ export const getRPC = async () => {
             const message = "Failed to load mobile worker bundle. Make sure the QVAC Expo plugin is configured. " +
                 `Add '@qvac/sdk/expo-plugin' to your app.json plugins array. ` +
                 `Error: ${String(error)}`;
-            console.error(message);
+            logger.error(message);
             throw new RPCConnectionFailedError(message, error instanceof Error ? error : undefined);
         }
         worklet.start("worker.bundle", mobileBundle, [
@@ -39,27 +96,28 @@ export const getRPC = async () => {
                 HOME_DIR: Paths.document.uri.replace("file://", ""),
             }),
         ]);
-        console.log("Worklet started");
+        logger.info("Worklet started");
         rpcInstance = new RPC(worklet.IPC, () => {
             // Use this for async callbacks
         });
-        const { replayConfigIfCached } = await import("../init-hooks.js");
-        await replayConfigIfCached(rpcInstance);
+        const runtimeContext = await getRuntimeContext();
+        await initializeConfig(rpcInstance, resolveConfig, runtimeContext);
+        workletInitialized = true;
         return rpcInstance;
     })();
     try {
         return await rpcPromise;
     }
     catch (error) {
-        console.error(`Failed to initialize RPC: ${String(error)}`);
+        logger.error(`Failed to initialize RPC: ${String(error)}`);
         throw error;
     }
     finally {
         rpcPromise = null;
     }
-};
-export const close = () => {
-    console.log("🧹 Closing RPC client (Expo)");
+}
+export function close() {
+    logger.info("🧹 Closing RPC client (Expo)");
     rpcInstance = null;
     rpcPromise = null;
-};
+}

package/dist/client/rpc/node-rpc-client.d.ts

@@ -5,5 +5,5 @@ export declare function getRPC(): {
         createResponseStream: () => AsyncGenerator<unknown, void, unknown>;
     };
 };
-export declare const close: () => void;
+export declare function close(): void;
 //# sourceMappingURL=node-rpc-client.d.ts.map

package/dist/client/rpc/node-rpc-client.js

@@ -5,6 +5,10 @@ import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { RPCRequestNotSentError } from "../../utils/errors-client.js";
+import { initializeConfig } from "../init-hooks.js";
+import { resolveConfig } from "../config-loader/resolve-config.node.js";
+import { getClientLogger } from "../../logging/index.js";
+const logger = getClientLogger();
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 let rpcInstance = null;
@@ -50,8 +54,11 @@ async function ensureRPC() {
         });
     });
     const rpc = await rpcPromise;
-    const { replayConfigIfCached } = await import("../init-hooks.js");
-    await replayConfigIfCached(rpc);
+    const runtimeContext = {
+        runtime: "node",
+        platform: process.platform,
+    };
+    await initializeConfig(rpc, resolveConfig, runtimeContext);
     return rpc;
 }
 const mockRPC = {
@@ -93,20 +100,20 @@ const mockRPC = {
 export function getRPC() {
     return mockRPC;
 }
-export const close = () => {
-    console.log("🧹 Closing RPC client");
+export function close() {
+    logger.info("🧹 Closing RPC client");
     if (bareWorkerProc) {
-        console.log("🐻🔫 Killing bare worker process");
+        logger.info("🐻🔫 Killing bare worker process");
         bareWorkerProc.kill("SIGTERM");
         bareWorkerProc = null;
     }
     if (ipcServer) {
-        console.log("🔌 Closing IPC server");
+        logger.info("🔌 Closing IPC server");
         ipcServer.close();
         ipcServer = null;
     }
     rpcInstance = null;
     rpcPromise = null;
-};
+}
 // Register cleanup handlers for the parent process
 process.once("exit", close);

package/dist/client/rpc/rpc-client.d.ts

@@ -2,5 +2,5 @@ import type RPC from "bare-rpc";
 import { type Request, type Response, type RPCOptions } from "../../schemas/index";
 export declare function send<T extends Request>(request: T, rpc?: RPC, options?: RPCOptions): Promise<Response>;
 export declare function stream<T extends Request>(request: T, rpc?: RPC, options?: RPCOptions): AsyncGenerator<Response>;
-export declare function close(): Promise<void>;
+export declare function close(): void;
 //# sourceMappingURL=rpc-client.d.ts.map

package/dist/client/rpc/rpc-client.js

@@ -1,6 +1,9 @@
 import { requestSchema, responseSchema, } from "../../schemas/index.js";
 import { RPCError } from "./rpc-error.js";
 import { withTimeout, withTimeoutStream } from "../../utils/withTimeout.js";
+import { getClientLogger, summarizeRequest } from "../../logging/index.js";
+import { getRPC, close as closeRPC } from "#rpc";
+const logger = getClientLogger();
 let rpcInstance = null;
 let commandCounter = 0;
 function getNextCommandId() {
@@ -12,66 +15,30 @@ function checkAndThrowError(response) {
         throw new RPCError(response);
     }
 }
-async function getRPC() {
+async function getRPCInstance() {
     if (rpcInstance)
         return rpcInstance;
-    const isRN = typeof navigator !== "undefined" && navigator.product === "ReactNative";
-    // Detect Bare runtime - Bare exposes global Bare object
-    // TODO we can use something like https://www.npmjs.com/package/which-runtime at some point
-    const isBare = typeof globalThis !== "undefined" && "Bare" in globalThis;
-    // TODO Lots of type unsafe hacks to make this work cross platform
-    if (isRN) {
-        console.log("React Native runtime detected");
-        // Only import expo client for React Native - Metro won't bundle the Node client
-        const expoRPCClientPath = "./expo-rpc-client";
-        const mod = (await import(expoRPCClientPath));
-        rpcInstance = await (typeof mod === "function" ? mod() : mod.getRPC());
-        return rpcInstance;
-    }
-    else if (isBare) {
-        console.log("Bare runtime detected");
-        // Use dynamic import for Bare client
-        const mod = await import("./bare-client.js");
-        rpcInstance = mod.getRPC();
-        return rpcInstance;
-    }
-    else {
-        console.log("Node runtime detected");
-        // Use dynamic import for Node client to prevent Metro from bundling it
-        const mod = await import("./node-rpc-client.js");
-        rpcInstance = mod.getRPC();
-        return rpcInstance;
-    }
+    rpcInstance = await getRPC();
+    return rpcInstance;
 }
 export async function send(request, rpc, options) {
     const parsedRequest = requestSchema.parse(request);
-    const rpcInstance = rpc || (await getRPC());
+    const rpcInstance = rpc || (await getRPCInstance());
     const req = rpcInstance.request(getNextCommandId());
-    // TODO temp for debugging, find a better solution to exclude large payloads
-    // Log request type and basic info, avoid logging large payloads
-    if (request.type === "transcribeStream") {
-        console.log("RPC Client sending:", {
-            type: request.type,
-            modelId: request.modelId,
-            audioChunkType: request.audioChunk.type,
-            audioChunkSize: request.audioChunk.value.length,
-        });
-    }
-    else {
-        console.log("RPC Client sending:", request);
-    }
+    logger.debug("RPC Client sending:", summarizeRequest(request));
     const payload = JSON.stringify(parsedRequest);
     req.send(payload, "utf-8");
     const response = await withTimeout(req.reply("utf-8"), options?.timeout);
     const resPayload = responseSchema.parse(JSON.parse(response?.toString() || "{}"));
-    console.log("ResPayload", { type: resPayload.type });
+    logger.debug("ResPayload", { type: resPayload.type });
     checkAndThrowError(resPayload);
     return resPayload;
 }
 export async function* stream(request, rpc, options = {}) {
     const parsedRequest = requestSchema.parse(request);
-    const rpcInstance = rpc || (await getRPC());
+    const rpcInstance = rpc || (await getRPCInstance());
     const req = rpcInstance.request(getNextCommandId());
+    logger.debug("RPC Client streaming:", summarizeRequest(request));
     req.send(JSON.stringify(parsedRequest), "utf-8");
     const responseStream = req.createResponseStream({ encoding: "utf-8" });
     let buffer = "";
@@ -95,21 +62,9 @@ export async function* stream(request, rpc, options = {}) {
         }
     }
 }
-export async function close() {
+export function close() {
     if (!rpcInstance)
         return;
-    const isRN = typeof navigator !== "undefined" && navigator.product === "ReactNative";
-    const isBare = typeof globalThis !== "undefined" && "Bare" in globalThis;
-    if (isRN) {
-        const mod = (await import("./expo-rpc-client.js"));
-        mod.close();
-    }
-    else if (isBare) {
-        // Bare runs in-process (no separate worker), so no cleanup needed
-    }
-    else {
-        const mod = (await import("./node-rpc-client.js"));
-        mod.close();
-    }
+    closeRPC();
     rpcInstance = null;
 }

package/dist/examples/config/blind-relay/blind-relay.config.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    swarmRelays: string[];
+};
+export default _default;
+//# sourceMappingURL=blind-relay.config.d.ts.map

package/dist/examples/config/blind-relay/blind-relay.config.js

@@ -0,0 +1,7 @@
+export default {
+    swarmRelays: [
+        "0000000000000000000000000000000000000000000000000000000000000001",
+        "0000000000000000000000000000000000000000000000000000000000000002",
+        "0000000000000000000000000000000000000000000000000000000000000003",
+    ],
+};

package/dist/examples/config/default/default.config.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    loggerLevel: string;
+    loggerConsoleOutput: boolean;
+    httpDownloadConcurrency: number;
+    httpConnectionTimeoutMs: number;
+};
+export default _default;
+//# sourceMappingURL=default.config.d.ts.map

package/dist/examples/config/default/default.config.js

@@ -0,0 +1,6 @@
+export default {
+    loggerLevel: "info",
+    loggerConsoleOutput: true,
+    httpDownloadConcurrency: 3,
+    httpConnectionTimeoutMs: 10000,
+};

package/dist/examples/config-reload.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=config-reload.d.ts.map

package/dist/examples/config-reload.js

@@ -0,0 +1,49 @@
+import { WHISPER_TINY, loadModel, transcribe, unloadModel } from "../index";
+// Parse command line arguments
+const args = process.argv.slice(2);
+if (!args[0]) {
+    console.error("Usage: bun run examples/config-reload.ts <audio-file-path>");
+    process.exit(1);
+}
+const audioFilePath = args[0];
+try {
+    // Initial load with English language
+    console.log("Loading Whisper model with English config...");
+    const modelId = await loadModel({
+        modelSrc: WHISPER_TINY,
+        modelType: "whisper",
+        modelConfig: {
+            language: "en",
+        },
+    });
+    // Transcribe with English config
+    console.log("Transcribing audio with English config...");
+    const englishText = await transcribe({
+        modelId,
+        audioChunk: audioFilePath,
+    });
+    console.log(`Transcription (EN): ${englishText}`);
+    console.log();
+    // Hot reload config - change language and temperature
+    console.log("Hot reloading config (changing language and temperature)...");
+    const reloadedId = await loadModel({
+        modelId,
+        modelType: "whisper",
+        modelConfig: {
+            language: "es", // Change to Spanish
+        },
+    });
+    console.log(`Config reloaded, same model ID: ${reloadedId === modelId}`);
+    // Transcribe again with updated config
+    console.log("Transcribing with updated config...");
+    const spanishText = await transcribe({
+        modelId,
+        audioChunk: audioFilePath,
+    });
+    console.log(`Transcription (ES): ${spanishText}`);
+    await unloadModel({ modelId });
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/default-config-usage.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Default Config Example
+ *
+ * This example demonstrates how to use a config file with the SDK.
+ *
+ * Supported config formats:
+ * - qvac.config.json (JSON)
+ * - qvac.config.js   (JavaScript with default export)
+ * - qvac.config.ts   (TypeScript with default export)
+ *
+ * Config resolution order:
+ * 1. QVAC_CONFIG_PATH environment variable (used here for demo purposes)
+ * 2. Config file in project root - auto-discovered, no env var needed
+ * 3. SDK defaults
+ */
+export {};
+//# sourceMappingURL=default-config-usage.d.ts.map

package/dist/examples/default-config-usage.js

@@ -0,0 +1,47 @@
+/**
+ * Default Config Example
+ *
+ * This example demonstrates how to use a config file with the SDK.
+ *
+ * Supported config formats:
+ * - qvac.config.json (JSON)
+ * - qvac.config.js   (JavaScript with default export)
+ * - qvac.config.ts   (TypeScript with default export)
+ *
+ * Config resolution order:
+ * 1. QVAC_CONFIG_PATH environment variable (used here for demo purposes)
+ * 2. Config file in project root - auto-discovered, no env var needed
+ * 3. SDK defaults
+ */
+// Note: This example uses .js file for the config
+// However it could be .json or .ts as well, depending on your needs.
+const configDir = import.meta.dirname ?? process.cwd();
+process.env["QVAC_CONFIG_PATH"] =
+    `${configDir}/config/default/default.config.js`;
+console.log(`🔍 Using config from: ${process.env["QVAC_CONFIG_PATH"]}`);
+const { loadModel, unloadModel, completion, LLAMA_3_2_1B_INST_Q4_0 } = await import("@qvac/sdk");
+try {
+    console.log("🚀 Loading model with configured settings...\n");
+    const modelId = await loadModel({
+        modelSrc: LLAMA_3_2_1B_INST_Q4_0,
+        modelType: "llm",
+    });
+    console.log("\n💬 Running completion...\n");
+    const result = completion({
+        modelId,
+        history: [
+            { role: "user", content: "Say 'Config works!' in exactly 3 words." },
+        ],
+        stream: true,
+    });
+    for await (const token of result.tokenStream) {
+        process.stdout.write(token);
+    }
+    console.log("\n");
+    await unloadModel({ modelId });
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}
+export {};

package/dist/examples/delegated-inference/consumer.js

@@ -32,6 +32,7 @@ try {
             providerPublicKey,
             timeout: 5_000, // Optional: 5 second timeout for delegated requests
             fallbackToLocal: true, // Optional: Fall back to local inference if delegation fails
+            // forceNewConnection: true, // Optional: Force a new connection instead of reusing cached one
         },
         onProgress: (progress) => {
             console.log(`📊 Download progress: ${progress.percentage.toFixed(1)}% (${progress.downloaded}/${progress.total} bytes)`);

package/dist/examples/download-with-blind-relays.js

@@ -1,26 +1,26 @@
-import { downloadAsset, setConfig, close, LLAMA_3_2_1B_INST_Q4_0, } from "@qvac/sdk";
-// ⚠️ IMPORTANT: These are MOCK relay public keys for demonstration only
-// To use blind relays in production:
-// 1. Run your own relay servers using hyperswarm
-// 2. Use well-known public relays from trusted sources
-// 3. Never rely on example/mock keys for production use
-const MOCK_RELAY_PUBLIC_KEYS = [
-    "0000000000000000000000000000000000000000000000000000000000000001",
-    "0000000000000000000000000000000000000000000000000000000000000002",
-    "0000000000000000000000000000000000000000000000000000000000000003",
-];
+// Set config path before importing SDK - the SDK loads config during initialization
+// This example uses a config file that defines blind relay public keys for improved P2P connectivity
+// Blind relays help establish connections through NAT/firewalls by acting as intermediaries
+const configDir = import.meta.dirname ?? process.cwd();
+process.env["QVAC_CONFIG_PATH"] =
+    `${configDir}/config/blind-relay/blind-relay.config.js`;
+import { downloadAsset, close, LLAMA_3_2_1B_INST_Q4_0, loadModel, getModelInfo, unloadModel, } from "@qvac/sdk";
 console.log(`🚀 Download with Blind Relays Example`);
 console.log(`${"=".repeat(60)}\n`);
-console.log(`⚠️  Using MOCK relay keys - replace with real relays!\n`);
 try {
-    // Configure SDK to use blind relays for improved connectivity
-    // Blind relays help with NAT traversal and firewall bypassing
-    await setConfig({
-        swarmRelays: MOCK_RELAY_PUBLIC_KEYS,
-    });
-    console.log(`✅ Configured ${MOCK_RELAY_PUBLIC_KEYS.length} blind relays`);
+    // Config is loaded from examples/config/qvac.config.json (set via QVAC_CONFIG_PATH above)
+    // The config contains swarmRelays - an array of Hyperswarm relay public keys
+    // These relays help with NAT traversal and firewall bypassing for P2P downloads
     console.log(`📥 Starting model download from Hyperdrive...\n`);
     const startTime = Date.now();
+    const modelId = await loadModel({
+        modelSrc: LLAMA_3_2_1B_INST_Q4_0,
+        modelType: "llm",
+    });
+    console.log(`Model loaded with ID: ${modelId}`);
+    const firstStatus = await getModelInfo(LLAMA_3_2_1B_INST_Q4_0);
+    console.log(`First status: ${JSON.stringify(firstStatus)}`);
+    await unloadModel({ modelId });
     // Download model with progress tracking
     await downloadAsset({
         assetSrc: LLAMA_3_2_1B_INST_Q4_0,
@@ -38,11 +38,12 @@ try {
     });
     console.log(`\n✅ Model downloaded successfully using blind relays!`);
     console.log(`Blind relays helped establish peer connections through NAT/firewalls\n`);
-    await close();
+    close();
 }
 catch (error) {
     console.error("❌ Error:", error);
-    console.log(`\nIf download failed, ensure you're using valid relay public keys`);
-    console.log(`   Mock keys in this example won't work in practice!`);
+    console.log(`\nIf download failed, check the relay public keys in:`);
+    console.log(`   examples/config/qvac.config.json`);
+    console.log(`   (Mock keys in this example won't work in practice!)`);
     process.exit(1);
 }