@qvac/sdk 0.1.0-dev.1760648187.328e967

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

@@ -0,0 +1,46 @@
+import { downloadAsset, cancel, 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;
+let cancelled = false;
+try {
+    // Download model with progress tracking and cancellation
+    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);
+            console.log(`📊 Progress: ${percentage}% (${downloadedMB}MB / ${totalMB}MB)`);
+            // Example: Stops at 35% (or use Ctrl+C for manual stop)
+            if (parseFloat(percentage) >= 35 && !cancelled) {
+                console.log("\n🚫 Auto-cancelling at 35% for demo purposes...,");
+                console.log(`📊 Progress: ${percentage}% (${downloadedMB}MB / ${totalMB}MB)`);
+                console.log(progress);
+                cancelled = true;
+                // Use the downloadKey to cancel
+                if (progress.downloadKey) {
+                    void cancel({
+                        operation: "downloadAsset",
+                        downloadKey: progress.downloadKey,
+                        // clearCache: true, // Uncomment to delete partial file instead of resuming
+                    });
+                }
+            }
+        },
+    });
+    console.log(`\n✅ Model downloaded successfully! Model ID: ${modelId}`);
+    console.log("🎯 Download completed without interruption");
+    // Clean up
+    process.exit(0);
+}
+catch (error) {
+    if (error instanceof Error && error.message.includes("cancelled")) {
+        console.log("✅ Download was successfully cancelled");
+        process.exit(0);
+    }
+    else {
+        console.error("❌ Error:", error);
+        process.exit(1);
+    }
+}

package/dist/examples/embed-hyperdrive.d.ts

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

package/dist/examples/embed-hyperdrive.js

@@ -0,0 +1,19 @@
+import { embed, GTE_LARGE_FP16, loadModel, unloadModel } from "@qvac/sdk";
+try {
+    const modelId = await loadModel({
+        modelSrc: GTE_LARGE_FP16,
+        modelType: "embeddings",
+        onProgress: (progress) => {
+            console.log(progress);
+        },
+    });
+    const embedding = await embed({ modelId, text: "Hello, world!" });
+    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);
+    process.exit(1);
+}

package/dist/examples/kv-cache-example.d.ts

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

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

@@ -0,0 +1,74 @@
+import { completion, LLAMA_3_2_1B_INST_Q4_0, loadModel, unloadModel, VERBOSITY, } from "@qvac/sdk";
+try {
+    // Load the model
+    const modelId = await loadModel({
+        modelSrc: LLAMA_3_2_1B_INST_Q4_0,
+        modelType: "llm",
+        modelConfig: {
+            device: "gpu",
+            ctx_size: 2048,
+            verbosity: VERBOSITY.SILENT,
+        },
+    });
+    console.log("🧠 Testing KV Cache functionality...\n");
+    // First conversation with cache enabled
+    console.log("📝 First conversation (building cache):");
+    const history1 = [
+        { role: "user", content: "What is the capital of France?" },
+    ];
+    const result1 = completion({
+        modelId,
+        history: history1,
+        stream: true,
+        kvCache: true,
+    }); // kvCache = true
+    let response1 = "";
+    for await (const token of result1.tokenStream) {
+        response1 += token;
+        process.stdout.write(token);
+    }
+    const stats1 = await result1.stats;
+    console.log(`\n⏱️  First completion stats: ${JSON.stringify(stats1)}\n`);
+    // Continue conversation (should reuse cache from previous conversation)
+    console.log("🔄 Continuing conversation (reusing cache):");
+    const history2 = [
+        { role: "user", content: "What is the capital of France?" },
+        { role: "assistant", content: response1.trim() },
+        { role: "user", content: "What about Germany?" },
+    ];
+    // This should:
+    // 1. Find existing cache from [user: "What is the capital of France?"] (history minus last message)
+    // 2. Load that cache and process the new "What about Germany?" message
+    // 3. Save the updated cache and rename it to include all messages
+    const result2 = completion({
+        modelId,
+        history: history2,
+        stream: true,
+        kvCache: true,
+    }); // kvCache = true
+    for await (const token of result2.tokenStream) {
+        process.stdout.write(token);
+    }
+    const stats2 = await result2.stats;
+    console.log(`\n⏱️  Second completion stats: ${JSON.stringify(stats2)}\n`);
+    // Compare with non-cached version
+    console.log("🚀 Same conversation without cache:");
+    const result3 = completion({
+        modelId,
+        history: history2,
+        stream: true,
+        kvCache: false,
+    }); // kvCache = false
+    for await (const token of result3.tokenStream) {
+        process.stdout.write(token);
+    }
+    const stats3 = await result3.stats;
+    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);
+    process.exit(1);
+}

package/dist/examples/llamacpp-file-logging.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=llamacpp-file-logging.d.ts.map

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

@@ -0,0 +1,62 @@
+import { getLogger } from "../logging/index.js";
+import { loadModel, completion, unloadModel } from "../client/api/index.js";
+import { writeFileSync, appendFileSync } from "fs";
+import { join } from "path";
+import { LLAMA_3_2_1B_INST_Q4_0 } from "../models/hyperdrive/index.js";
+try {
+    const logFile = join(process.cwd(), "model-logs.txt");
+    // Clear previous logs
+    writeFileSync(logFile, "");
+    // Create logger with file transport
+    const logger = getLogger("llm-file-demo", {
+        level: "debug",
+        transports: [
+            // File transport - append logs to file
+            (level, namespace, message) => {
+                const timestamp = new Date().toISOString();
+                const logLine = `[${timestamp}] ${level.toUpperCase()} ${namespace}: ${message}\n`;
+                appendFileSync(logFile, logLine);
+            },
+            // Console transport for immediate feedback
+            (level, namespace, message) => {
+                console.log(`🔍 [${level.toUpperCase()}] ${namespace}: ${message}`);
+            },
+        ],
+    });
+    logger.info("Starting model demo with file logging");
+    // Load model with integrated logging
+    const modelId = await loadModel({
+        modelSrc: LLAMA_3_2_1B_INST_Q4_0,
+        modelType: "llm",
+        modelConfig: {
+            ctx_size: 2048,
+            temp: 0.7,
+        },
+        logger, // All model logs will be captured
+    });
+    logger.info(`Model loaded: ${modelId}`);
+    // Run a simple completion
+    logger.info("Starting completion...");
+    const messages = [
+        { role: "user", content: "Tell me a short joke about programming." },
+    ];
+    let responseText = "";
+    const result = completion({ modelId, history: messages, stream: true });
+    for await (const token of result.tokenStream) {
+        responseText += token;
+        process.stdout.write(token);
+    }
+    console.log("\n");
+    logger.info(`Completion finished, ${responseText.length} characters generated`);
+    // Unload model
+    await unloadModel({ modelId });
+    logger.info("Model unloaded successfully");
+    // 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);
+    process.exit(1);
+}

package/dist/examples/llamacpp-filesystem.d.ts

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

package/dist/examples/llamacpp-filesystem.js

@@ -0,0 +1,40 @@
+import { completion, loadModel } from "@qvac/sdk";
+// Get GGUF file path from command line arguments
+const ggufPath = process.argv[2];
+if (!ggufPath) {
+    console.error("❌ Error: Please provide the path to a GGUF file as the first argument");
+    console.error("Usage: bun run examples/llamacpp-filesystem.ts <path-to-gguf-file>");
+    process.exit(1);
+}
+console.log(`🚀 Loading GGUF model from: ${ggufPath}`);
+try {
+    // Load model from provided file path
+    const modelId = await loadModel({
+        modelSrc: ggufPath,
+        modelType: "llm",
+        modelConfig: {
+            ctx_size: 4096,
+        },
+        onProgress: (progress) => console.log(`Loading: ${progress.percentage.toFixed(1)}%`),
+    });
+    console.log(`✅ Model loaded successfully! Model ID: ${modelId}`);
+    // Create conversation history
+    const history = [
+        { role: "user", content: "Explain Bitcoin in 3 key points" },
+    ];
+    console.log("\n🤖 AI Response:");
+    process.stdout.write(""); // Start response on new line
+    // Stream completion
+    const result = completion({ modelId, history, stream: true });
+    for await (const token of result.tokenStream) {
+        process.stdout.write(token);
+    }
+    const stats = await result.stats;
+    console.log("\n📊 Performance Stats:", stats);
+    console.log("\n\n🎉 Completed!");
+    process.exit(0);
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/llamacpp-http.d.ts

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

package/dist/examples/llamacpp-http.js

@@ -0,0 +1,41 @@
+import { completion, loadModel, unloadModel } from "@qvac/sdk";
+// Get HTTP URL from command line arguments or use default HuggingFace URL
+const httpUrl = process.argv[2] ||
+    "https://huggingface.co/bartowski/Llama-3.2-1B-Instruct-GGUF/resolve/main/Llama-3.2-1B-Instruct-Q4_0.gguf";
+console.log(`🚀 Loading GGUF model from HTTP: ${httpUrl}`);
+try {
+    // Load model from HTTP URL
+    const modelId = await loadModel({
+        modelSrc: httpUrl,
+        modelType: "llm",
+        modelConfig: {
+            ctx_size: 4096,
+        },
+        onProgress: (progress) => {
+            const downloadedMB = (progress.downloaded / 1024 / 1024).toFixed(2);
+            const totalMB = (progress.total / 1024 / 1024).toFixed(2);
+            console.log(`Loading: ${progress.percentage.toFixed(1)}% (${downloadedMB}MB / ${totalMB}MB)`);
+        },
+    });
+    console.log(`✅ Model loaded successfully! Model ID: ${modelId}`);
+    // Create conversation history
+    const history = [
+        { role: "user", content: "Explain quantum computing in 3 key points" },
+    ];
+    console.log("\n🤖 AI Response:");
+    process.stdout.write(""); // Start response on new line
+    // Stream completion
+    const result = completion({ modelId, history, stream: true });
+    for await (const token of result.tokenStream) {
+        process.stdout.write(token);
+    }
+    const stats = await result.stats;
+    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);
+    process.exit(1);
+}

package/dist/examples/llamacpp-hyperdrive.d.ts

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

package/dist/examples/llamacpp-hyperdrive.js

@@ -0,0 +1,39 @@
+import { completion, LLAMA_3_2_1B_INST_Q4_0, loadModel, downloadAsset, unloadModel, VERBOSITY, } from "@qvac/sdk";
+try {
+    // First just cache the model
+    await downloadAsset({
+        assetSrc: LLAMA_3_2_1B_INST_Q4_0,
+        onProgress: (progress) => {
+            console.log(progress);
+        },
+    });
+    // Then load it in memory from cache
+    const modelId = await loadModel({
+        modelSrc: LLAMA_3_2_1B_INST_Q4_0,
+        modelType: "llm",
+        modelConfig: {
+            device: "gpu",
+            ctx_size: 2048,
+            verbosity: VERBOSITY.SILENT,
+        },
+    });
+    const history = [
+        {
+            role: "user",
+            content: "Explain quantum computing in one sentence, use lots of emojis",
+        },
+    ];
+    const result = completion({ modelId, history, stream: true });
+    for await (const token of result.tokenStream) {
+        process.stdout.write(token);
+    }
+    const stats = await result.stats;
+    console.log("\n📊 Performance Stats:", stats);
+    // Change `clearStorage: true` to delete cached model files
+    await unloadModel({ modelId, clearStorage: false });
+    process.exit(0);
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/llamacpp-multimodal.d.ts

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

package/dist/examples/llamacpp-multimodal.js

@@ -0,0 +1,62 @@
+import { completion, loadModel, unloadModel } from "@qvac/sdk";
+if (process.argv.length < 3) {
+    console.error(`Specify an image file path as the first argument and a second image file path as the second (optional) argument`);
+    process.exit(1);
+}
+try {
+    // const modelPath = args[modelIndex + 1]!;
+    const imageFilePath = process.argv[2];
+    // Load the main model with projection in a single step
+    const modelId = await loadModel({
+        modelSrc: "https://huggingface.co/ggml-org/SmolVLM2-500M-Video-Instruct-GGUF/resolve/main/SmolVLM2-500M-Video-Instruct-Q8_0.gguf",
+        modelType: "llm",
+        projectionModelSrc: "https://huggingface.co/ggml-org/SmolVLM2-500M-Video-Instruct-GGUF/resolve/main/mmproj-SmolVLM2-500M-Video-Instruct-Q8_0.gguf",
+        modelConfig: {
+            ctx_size: 1024,
+        },
+        onProgress: (progress) => {
+            console.log(`Loading: ${progress.percentage.toFixed(1)}%`);
+        },
+    });
+    //Using one particular media
+    const history = [
+        {
+            role: "user",
+            content: "What's in this image?",
+            attachments: [{ path: imageFilePath }],
+        },
+    ];
+    const result = completion({ modelId, history, stream: true });
+    for await (const token of result.tokenStream) {
+        process.stdout.write(token);
+    }
+    const stats = await result.stats;
+    console.log("\n📊 Performance Stats:", stats);
+    console.log("--------------------------------");
+    //Using multiple media
+    if (process.argv.length < 4) {
+        console.log(`Only one image provided, terminating`);
+        process.exit(0);
+    }
+    const imageFilePath2 = process.argv[3];
+    const history2 = [
+        {
+            role: "user",
+            content: "Compare the two newspaper articles",
+            attachments: [{ path: imageFilePath }, { path: imageFilePath2 }],
+        },
+    ];
+    const result2 = completion({ modelId, history: history2, stream: true });
+    for await (const token of result2.tokenStream) {
+        process.stdout.write(token);
+    }
+    const stats2 = await result2.stats;
+    console.log("\n📊 Performance Stats:", stats2);
+    console.log("--------------------------------");
+    await unloadModel({ modelId, clearStorage: false });
+    process.exit(0);
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/llamacpp-native-tools.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=llamacpp-native-tools.d.ts.map

package/dist/examples/llamacpp-native-tools.js

@@ -0,0 +1,64 @@
+import { completion, loadModel, unloadModel } from "@qvac/sdk";
+// Get GGUF file path from command line arguments
+const ggufPath = process.argv[2];
+if (!ggufPath) {
+    console.error("❌ Error: Please provide the path to a GGUF file as the first argument");
+    console.error("Usage: bun run examples/llamacpp-native-tools.ts <path-to-gguf-file>");
+    process.exit(1);
+}
+// Tool definition
+const tools = [
+    {
+        type: "function",
+        name: "get_horoscope",
+        description: "Get today's horoscope for an astrological sign.",
+        parameters: {
+            type: "object",
+            properties: {
+                sign: {
+                    type: "string",
+                    description: "An astrological sign like Taurus or Aquarius",
+                },
+            },
+            required: ["sign"],
+        },
+    },
+];
+// @ts-expect-error - Function will be used in future implementation
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function getHoroscope(sign) {
+    return sign + " Next Tuesday you will befriend a baby otter.";
+}
+console.log(`🚀 Loading GGUF model from: ${ggufPath}`);
+try {
+    // Load model from provided file path
+    const modelId = await loadModel({
+        modelSrc: ggufPath,
+        modelType: "llm",
+        modelConfig: {
+            ctx_size: 4096,
+        },
+        onProgress: (progress) => console.log(`Loading: ${progress.percentage.toFixed(1)}%`),
+    });
+    console.log(`✅ Model loaded successfully! Model ID: ${modelId}`);
+    // Create conversation history
+    const history = [
+        { role: "user", content: "Explain Bitcoin in 3 key points" },
+    ];
+    console.log("\n🤖 AI Response:");
+    process.stdout.write(""); // Start response on new line
+    // Stream completion
+    const result = completion({ modelId, history, stream: true, tools });
+    for await (const token of result.tokenStream) {
+        process.stdout.write(token);
+    }
+    const stats = await result.stats;
+    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);
+    process.exit(1);
+}

package/dist/examples/llamacpp-tools-routing.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=llamacpp-tools-routing.d.ts.map