@qvac/sdk 0.3.0 → 0.4.1

package/dist/client/init-hooks.js

@@ -0,0 +1,37 @@
+import { getCachedConfig } from "./config-manager.js";
+/**
+ * Replays cached configuration to the worker after initialization.
+ * This ensures config persists across worker restarts.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const replayConfigIfCached = async (rpc) => {
+    const config = getCachedConfig();
+    if (!config) {
+        console.log("No cached config to replay");
+        return;
+    }
+    console.log("🔄 Replaying cached config to worker:", config);
+    try {
+        const request = {
+            type: "setConfig",
+            config,
+        };
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        const req = rpc.request(1);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        req.send(JSON.stringify(request), "utf8");
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        const response = await req.reply("utf8");
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        const parsed = JSON.parse(response.toString());
+        if (parsed.type !== "setConfig" || !parsed.success) {
+            console.error("Failed to replay config:", parsed.error);
+        }
+        else {
+            console.log("✅ Config successfully replayed to worker");
+        }
+    }
+    catch (error) {
+        console.error("Error replaying config:", error);
+    }
+};

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

@@ -13,17 +13,51 @@ export declare function stream<T extends Request>(request: T): AsyncGenerator<{
         tokensPerSecond: number;
         cacheTokens: number;
     } | undefined;
+    toolCallEvent?: {
+        type: "toolCall";
+        call: {
+            id: string;
+            name: string;
+            arguments: Record<string, unknown>;
+            raw?: string | undefined;
+        };
+    } | {
+        type: "toolCallError";
+        error: {
+            code: "PARSE_ERROR" | "VALIDATION_ERROR" | "UNKNOWN_TOOL";
+            message: string;
+            raw?: string | undefined;
+        };
+    } | undefined;
+    toolCalls?: {
+        id: string;
+        name: string;
+        arguments: Record<string, unknown>;
+        raw?: string | undefined;
+    }[] | undefined;
     error?: string | undefined;
 } | {
     type: "deleteCache";
     success: boolean;
     error?: string | undefined;
+} | {
+    type: "textToSpeech";
+    buffer: number[];
+    done: boolean;
 } | {
     type: "modelProgress";
     downloaded: number;
     total: number;
     percentage: number;
     downloadKey: string;
+    shardInfo?: {
+        currentShard: number;
+        totalShards: number;
+        shardName: string;
+        overallDownloaded: number;
+        overallTotal: number;
+        overallPercentage: number;
+    } | undefined;
 } | {
     type: "loadModel";
     success: boolean;
@@ -59,6 +93,8 @@ export declare function stream<T extends Request>(request: T): AsyncGenerator<{
     type: "unloadModel";
     success: boolean;
     error?: string | undefined;
+    hasActiveModels?: boolean | undefined;
+    hasActiveProviders?: boolean | undefined;
 } | {
     type: "pong";
     number: number;
@@ -110,6 +146,39 @@ export declare function stream<T extends Request>(request: T): AsyncGenerator<{
     success: boolean;
     operation: "deleteEmbeddings";
     error?: string | undefined;
+} | {
+    type: "setConfig";
+    success: boolean;
+    error?: string | undefined;
+} | {
+    type: "getModelInfo";
+    modelInfo: {
+        name: string;
+        modelId: string;
+        hyperdriveKey: string;
+        hyperbeeKey: string;
+        expectedSize: number;
+        sha256Checksum: string;
+        addon: "llm" | "whisper" | "embeddings" | "nmt" | "vad" | "tts";
+        isCached: boolean;
+        isLoaded: boolean;
+        cacheFiles: {
+            filename: string;
+            path: string;
+            expectedSize: number;
+            sha256Checksum: string;
+            isCached: boolean;
+            actualSize?: number | undefined;
+            cachedAt?: Date | undefined;
+        }[];
+        actualSize?: number | undefined;
+        cachedAt?: Date | undefined;
+        loadedInstances?: {
+            registryId: string;
+            loadedAt: Date;
+            config?: unknown;
+        }[] | undefined;
+    };
 }, void, any>;
 export declare function getRPC(): {
     request(): {

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

@@ -1,4 +1,5 @@
 import { handlers } from "../../server/rpc/handlers/index.js";
+import { RPCNoHandlerError, RPCRequestNotSentError, } from "../../utils/errors-client.js";
 // Get the handler for a request type
 const getHandler = (type) => {
     const handler = handlers[type];
@@ -10,13 +11,13 @@ export async function send(request) {
     }
     const handler = getHandler(request.type);
     if (!handler)
-        throw new Error(`No handler function for ${request.type}`);
+        throw new RPCNoHandlerError(request.type);
     return (await handler(request));
 }
 export async function* stream(request) {
     const handler = getHandler(request.type);
     if (!handler)
-        throw new Error(`No handler function for ${request.type}`);
+        throw new RPCNoHandlerError(request.type);
     // Special handling for loadModel with progress
     if (request.type === "loadModel" &&
         "withProgress" in request &&
@@ -94,14 +95,14 @@ const createMockRPCRequest = () => {
         },
         async reply() {
             if (!requestData) {
-                throw new Error("No request data - call send() first");
+                throw new RPCRequestNotSentError();
             }
             const response = await send(requestData);
             return Buffer.from(JSON.stringify(response));
         },
         async *createResponseStream() {
             if (!requestData) {
-                throw new Error("No request data - call send() first");
+                throw new RPCRequestNotSentError();
             }
             for await (const response of stream(requestData)) {
                 yield Buffer.from(JSON.stringify(response) + "\n");

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

@@ -23,10 +23,10 @@ else {
     WORKER_PATH = path.resolve(cwd, "dist/server/worker.js");
 }
 const SOCKET_PATH = path.join(os.tmpdir(), `qvac-worker-${process.pid}.sock`);
-export function getRPC() {
+export async function getRPC() {
     if (rpcInstance) {
         console.log("returning cached bare rpc");
-        return Promise.resolve(rpcInstance);
+        return rpcInstance;
     }
     console.log("initRPC for bare runtime with socket:", SOCKET_PATH);
     // Start IPC server (Unix socket)
@@ -71,7 +71,11 @@ export function getRPC() {
             });
         });
     });
-    return serverPromise;
+    // Wait for RPC to initialize, then replay config
+    const rpc = await serverPromise;
+    const { replayConfigIfCached } = await import("../init-hooks.js");
+    await replayConfigIfCached(rpc);
+    return rpc;
 }
 // Clean up function
 export const cleanup = () => {

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

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

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

@@ -1,4 +1,5 @@
 import RPC from "bare-rpc";
+import { RPCConnectionFailedError } from "../../utils/errors-client.js";
 let rpcInstance = null;
 let rpcPromise = null;
 console.log("EXPO RPC Client bundle");
@@ -28,7 +29,7 @@ export const getRPC = async () => {
                 `Add '@qvac/sdk/expo-plugin' to your app.json plugins array. ` +
                 `Error: ${String(error)}`;
             console.error(message);
-            throw new Error(message);
+            throw new RPCConnectionFailedError(message, error instanceof Error ? error : undefined);
         }
         worklet.start("worker.bundle", mobileBundle, [
             // Normalize arg number across platforms
@@ -42,6 +43,8 @@ export const getRPC = async () => {
         rpcInstance = new RPC(worklet.IPC, () => {
             // Use this for async callbacks
         });
+        const { replayConfigIfCached } = await import("../init-hooks.js");
+        await replayConfigIfCached(rpcInstance);
         return rpcInstance;
     })();
     try {
@@ -55,3 +58,8 @@ export const getRPC = async () => {
         rpcPromise = null;
     }
 };
+export const close = () => {
+    console.log("🧹 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 cleanup: () => void;
+export declare const close: () => void;
 //# sourceMappingURL=node-rpc-client.d.ts.map

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

@@ -4,11 +4,13 @@ import { createServer } from "node:net";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { RPCRequestNotSentError } from "../../utils/errors-client.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 let rpcInstance = null;
 let rpcPromise = null;
 let bareWorkerProc = null;
+let ipcServer = null;
 // Smart path resolution for worker
 let WORKER_PATH;
 if (__dirname.includes("/dist/") || __dirname.includes("\\dist\\")) {
@@ -29,12 +31,12 @@ async function ensureRPC() {
     if (rpcPromise)
         return rpcPromise;
     rpcPromise = new Promise((resolve, reject) => {
-        const server = createServer((socket) => {
+        ipcServer = createServer((socket) => {
             rpcInstance = new RPC(socket, () => { });
             resolve(rpcInstance);
         });
-        server.on("error", reject);
-        server.listen(SOCKET_PATH, () => {
+        ipcServer.on("error", reject);
+        ipcServer.listen(SOCKET_PATH, () => {
             bareWorkerProc = spawn("bare", {
                 args: [
                     WORKER_PATH,
@@ -47,7 +49,10 @@ async function ensureRPC() {
             });
         });
     });
-    return rpcPromise;
+    const rpc = await rpcPromise;
+    const { replayConfigIfCached } = await import("../init-hooks.js");
+    await replayConfigIfCached(rpc);
+    return rpc;
 }
 const mockRPC = {
     request: (command) => {
@@ -58,7 +63,7 @@ const mockRPC = {
             },
             reply: async (encoding) => {
                 if (!sentData) {
-                    throw new Error("Must call send() before reply()");
+                    throw new RPCRequestNotSentError();
                 }
                 const rpc = await ensureRPC();
                 const req = rpc.request(command);
@@ -70,7 +75,7 @@ const mockRPC = {
             },
             createResponseStream: async function* () {
                 if (!sentData) {
-                    throw new Error("Must call send() before createResponseStream()");
+                    throw new RPCRequestNotSentError();
                 }
                 const rpc = await ensureRPC();
                 const req = rpc.request(command);
@@ -88,12 +93,20 @@ const mockRPC = {
 export function getRPC() {
     return mockRPC;
 }
-export const cleanup = () => {
-    console.log("🧹 Cleaning up RPC client");
+export const close = () => {
+    console.log("🧹 Closing RPC client");
     if (bareWorkerProc) {
         console.log("🐻🔫 Killing bare worker process");
         bareWorkerProc.kill("SIGTERM");
+        bareWorkerProc = null;
     }
+    if (ipcServer) {
+        console.log("🔌 Closing IPC server");
+        ipcServer.close();
+        ipcServer = null;
+    }
+    rpcInstance = null;
+    rpcPromise = null;
 };
 // Register cleanup handlers for the parent process
-process.once("exit", cleanup);
+process.once("exit", close);

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

@@ -2,4 +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>;
 //# sourceMappingURL=rpc-client.d.ts.map

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

@@ -53,7 +53,8 @@ export async function send(request, rpc, options) {
         console.log("RPC Client sending:", {
             type: request.type,
             modelId: request.modelId,
-            audioChunkSize: request.audioChunk.length,
+            audioChunkType: request.audioChunk.type,
+            audioChunkSize: request.audioChunk.value.length,
         });
     }
     else {
@@ -94,3 +95,21 @@ export async function* stream(request, rpc, options = {}) {
         }
     }
 }
+export async 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();
+    }
+    rpcInstance = null;
+}

package/dist/constants/audio.d.ts

@@ -1,3 +1,2 @@
-export declare const FORMATS_NEEDING_DECODE: readonly [".mp3", ".m4a", ".ogg", ".flac", ".aac", ".wav"];
-export declare const SUPPORTED_AUDIO_FORMATS: readonly [".mp3", ".m4a", ".ogg", ".wav", ".flac", ".aac", ".raw"];
+export { FORMATS_NEEDING_DECODE, SUPPORTED_AUDIO_FORMATS, } from "@qvac/decoder-audio/constants";
 //# sourceMappingURL=audio.d.ts.map

package/dist/constants/audio.js

@@ -1,17 +1 @@
-export const FORMATS_NEEDING_DECODE = [
-    ".mp3",
-    ".m4a",
-    ".ogg",
-    ".flac",
-    ".aac",
-    ".wav",
-];
-export const SUPPORTED_AUDIO_FORMATS = [
-    ".mp3",
-    ".m4a",
-    ".ogg",
-    ".wav",
-    ".flac",
-    ".aac",
-    ".raw",
-];
+export { FORMATS_NEEDING_DECODE, SUPPORTED_AUDIO_FORMATS, } from "@qvac/decoder-audio/constants.js";

package/dist/examples/cache-management.d.ts

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

package/dist/examples/cache-management.js

@@ -0,0 +1,97 @@
+import { WHISPER_TINY } from "../models/hyperdrive/index.js";
+import { downloadAsset, getModelInfo, loadModel, unloadModel } from "..";
+const printModelStatus = (info, label) => {
+    console.log(`\n${label}`);
+    console.log(`   Model Name: ${info.name}`);
+    console.log(`   Model ID: ${info.modelId}`);
+    console.log(`   Hyperdrive Key: ${info.hyperdriveKey.substring(0, 16)}...`);
+    console.log(`   Expected Size: ${(info.expectedSize / 1024 / 1024).toFixed(2)} MB`);
+    console.log(`   Addon: ${info.addon}`);
+    console.log(`   Cache Files: ${info.cacheFiles.length}`);
+    console.log(`   Is Cached: ${info.isCached ? "✅" : "❌"}`);
+    console.log(`   Is Loaded: ${info.isLoaded ? "✅" : "❌"}`);
+    if (info.isCached) {
+        if (info.cacheFiles.length === 1) {
+            console.log(`   Cache Path: ${info.cacheFiles[0]?.path}`);
+        }
+        else {
+            const cachedFiles = info.cacheFiles.filter((f) => f.isCached).length;
+            console.log(`     Cached: ${cachedFiles}/${info.cacheFiles.length}`);
+        }
+        console.log(`   Actual Size: ${(info.actualSize / 1024 / 1024).toFixed(2)} MB`);
+        console.log(`   Cached At: ${info.cachedAt?.toLocaleString()}`);
+    }
+    if (info.loadedInstances && info.loadedInstances.length > 0) {
+        console.log(`   Loaded Instances: ${info.loadedInstances.length}`);
+        info.loadedInstances.forEach((instance, i) => {
+            console.log(`     ${i + 1}. Registry ID: ${instance.registryId}`);
+            console.log(`        Loaded At: ${instance.loadedAt.toLocaleString()}`);
+        });
+    }
+};
+try {
+    console.log("=== Model Cache Management Demo ===");
+    // 1. Check initial status
+    console.log("\n1️⃣  INITIAL STATUS CHECK");
+    const initialInfo = await getModelInfo(WHISPER_TINY);
+    printModelStatus(initialInfo, "Initial Status:");
+    // 2. Download if not cached
+    if (!initialInfo.isCached) {
+        console.log("\n2️⃣  DOWNLOADING MODEL (not cached)");
+        console.log("   Downloading from hyperdrive...");
+        await downloadAsset({ assetSrc: WHISPER_TINY });
+        console.log("   ✅ Download complete!");
+        const afterDownload = await getModelInfo(WHISPER_TINY);
+        printModelStatus(afterDownload, "Status After Download:");
+    }
+    else {
+        console.log("\n2️⃣  MODEL ALREADY CACHED");
+        console.log("   Skipping download...");
+    }
+    // 3. Load if not loaded
+    console.log("\n3️⃣  LOADING MODEL INTO MEMORY");
+    const beforeLoad = await getModelInfo(WHISPER_TINY);
+    let modelId;
+    if (!beforeLoad.isLoaded) {
+        console.log("   Loading model into memory...");
+        modelId = await loadModel({
+            modelSrc: WHISPER_TINY,
+            modelType: "whisper",
+        });
+        console.log(`   ✅ Model loaded! ID: ${modelId}`);
+        const afterLoad = await getModelInfo(WHISPER_TINY);
+        printModelStatus(afterLoad, "Status After Load:");
+    }
+    else {
+        console.log("   Model already loaded!");
+        const instances = beforeLoad.loadedInstances;
+        if (!instances || instances.length === 0) {
+            throw new Error("Model is loaded but no instances found");
+        }
+        const firstInstance = instances[0];
+        if (!firstInstance) {
+            throw new Error("First instance is undefined");
+        }
+        modelId = firstInstance.registryId;
+        console.log(`   Using existing model ID: ${modelId}`);
+    }
+    // 4. Demonstrate unload
+    console.log("\n4️⃣  UNLOADING MODEL");
+    console.log("   Unloading model from memory...");
+    await unloadModel({ modelId });
+    console.log("   ✅ Model unloaded!");
+    const afterUnload = await getModelInfo(WHISPER_TINY);
+    printModelStatus(afterUnload, "Status After Unload:");
+    // 5. Summary
+    console.log("\n5️⃣  SUMMARY");
+    console.log("   ✅ Model Info API works correctly");
+    console.log("   ✅ Cache status tracked accurately");
+    console.log("   ✅ Loaded status reflects memory state");
+    console.log("   ✅ All operations completed successfully");
+    console.log("\n=== Demo Complete ===\n");
+    process.exit(0);
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

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

@@ -1,4 +1,4 @@
-import { completion, LLAMA_3_2_1B_INST_Q4_0, loadModel } from "@qvac/sdk";
+import { completion, LLAMA_3_2_1B_INST_Q4_0, loadModel, close, } from "@qvac/sdk";
 // Topic hex (required)
 const topicHex = process.argv[2];
 if (!topicHex) {
@@ -48,7 +48,7 @@ try {
     }
     console.log("🔍 Stats:", await response.stats);
     console.log("\n🎯 Delegation infrastructure working! Server correctly detected and routed the delegated request.");
-    process.exit(0);
+    void close();
 }
 catch (error) {
     console.error("❌ Error:", error);

package/dist/examples/download-with-blind-relays.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=download-with-blind-relays.d.ts.map

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

@@ -0,0 +1,48 @@
+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",
+];
+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`);
+    console.log(`📥 Starting model download from Hyperdrive...\n`);
+    const startTime = Date.now();
+    // Download model with progress tracking
+    await downloadAsset({
+        assetSrc: LLAMA_3_2_1B_INST_Q4_0,
+        onProgress: (progress) => {
+            const downloadedMB = (progress.downloaded / 1024 / 1024).toFixed(2);
+            const totalMB = (progress.total / 1024 / 1024).toFixed(2);
+            const percentage = progress.percentage.toFixed(1);
+            const elapsedSeconds = (Date.now() - startTime) / 1000;
+            const speedMBps = (progress.downloaded /
+                1024 /
+                1024 /
+                elapsedSeconds).toFixed(2);
+            console.log(`📊 ${percentage}% - ${downloadedMB}MB / ${totalMB}MB (${speedMBps} MB/s)`);
+        },
+    });
+    console.log(`\n✅ Model downloaded successfully using blind relays!`);
+    console.log(`Blind relays helped establish peer connections through NAT/firewalls\n`);
+    await 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!`);
+    process.exit(1);
+}

package/dist/examples/download-with-cancel.js

@@ -1,4 +1,4 @@
-import { downloadAsset, cancel, LLAMA_3_2_1B_INST_Q4_0 } from "@qvac/sdk";
+import { cancel, close, downloadAsset, LLAMA_3_2_1B_INST_Q4_0, } from "@qvac/sdk";
 console.log(`🚀 Starting download with pause/resume example`);
 console.log(`\n💡 Press Ctrl+C to pause the download (it will resume on restart)\n`);
 let modelId;
@@ -31,13 +31,12 @@ try {
     });
     console.log(`\n✅ Model downloaded successfully! Model ID: ${modelId}`);
     console.log("🎯 Download completed without interruption");
-    // Clean up
-    process.exit(0);
+    void close();
 }
 catch (error) {
     if (error instanceof Error && error.message.includes("cancelled")) {
         console.log("✅ Download was successfully cancelled");
-        process.exit(0);
+        void close();
     }
     else {
         console.error("❌ Error:", error);

package/dist/examples/embed-hyperdrive.js

@@ -11,7 +11,6 @@ try {
     console.log("Embedding (first 20 elements)", embedding.slice(0, 20));
     console.log("Embeddings length", embedding.length);
     await unloadModel({ modelId, clearStorage: false });
-    process.exit(0);
 }
 catch (error) {
     console.error("❌ Error:", error);

package/dist/examples/kv-cache-cleanup.js

@@ -80,7 +80,6 @@ try {
     console.log("   - Privacy → Clear conversation history");
     console.log("   - App reset → Delete all caches with { all: true }");
     await unloadModel({ modelId, clearStorage: false });
-    process.exit(0);
 }
 catch (error) {
     console.error("❌ Error:", error);

package/dist/examples/kv-cache-custom-key.js

@@ -79,7 +79,6 @@ try {
     console.log("   - Different cache keys provide complete isolation between sessions");
     await deleteCache({ all: true });
     await unloadModel({ modelId, clearStorage: false });
-    process.exit(0);
 }
 catch (error) {
     console.error("❌ Error:", error);

package/dist/examples/kv-cache-example.js

@@ -66,7 +66,6 @@ try {
     console.log(`\n⏱️  Non-cached completion stats: ${JSON.stringify(stats3)}\n`);
     console.log("✅ KV Cache test completed!");
     await unloadModel({ modelId, clearStorage: false });
-    process.exit(0);
 }
 catch (error) {
     console.error("❌ Error:", error);

package/dist/examples/llamacpp-file-logging.js

@@ -54,7 +54,6 @@ try {
     // Show user where logs were saved
     console.log(`\n📄 All logs (including model internals) saved to: ${logFile}`);
     console.log("You can inspect the file to see detailed model operation logs!");
-    process.exit(0);
 }
 catch (error) {
     console.error("❌ Error:", error);

package/dist/examples/llamacpp-filesystem.js

@@ -1,4 +1,4 @@
-import { completion, loadModel } from "@qvac/sdk";
+import { completion, loadModel, unloadModel } from "@qvac/sdk";
 // Get GGUF file path from command line arguments
 const ggufPath = process.argv[2];
 if (!ggufPath) {
@@ -32,7 +32,7 @@ try {
     const stats = await result.stats;
     console.log("\n📊 Performance Stats:", stats);
     console.log("\n\n🎉 Completed!");
-    process.exit(0);
+    await unloadModel({ modelId, clearStorage: false });
 }
 catch (error) {
     console.error("❌ Error:", error);

package/dist/examples/llamacpp-http.js

@@ -33,7 +33,6 @@ try {
     console.log("\n📊 Performance Stats:", stats);
     console.log("\n\n🎉 Completed!");
     await unloadModel({ modelId, clearStorage: false });
-    process.exit(0);
 }
 catch (error) {
     console.error("❌ Error:", error);