@qvac/sdk 0.10.2 → 0.12.0

package/dist/examples/diffusion-esrgan-upscale.js

@@ -0,0 +1,78 @@
+import { loadModel, unloadModel, diffusion, SD_V2_1_1B_Q8_0, REALESRGAN_X4PLUS_ANIME_6B, } from "@qvac/sdk";
+import fs from "fs";
+import path from "path";
+// ESRGAN upscale example.
+//
+// Usage:
+//   bun run examples/diffusion-esrgan-upscale.ts [esrganSrc] [prompt] [outputDir]
+const esrganArg = process.argv[2];
+const promptArg = process.argv[3];
+const outputDirArg = process.argv[4];
+const esrganModelSrc = esrganArg ??
+    REALESRGAN_X4PLUS_ANIME_6B;
+const prompt = promptArg ??
+    "an illustrated red fox portrait, clean line art, soft watercolor background, detailed fur, crisp eyes";
+const negative_prompt = "blurry, low quality, watermark, text";
+const outputDir = outputDirArg ?? ".";
+const seed = 42;
+try {
+    console.log("Loading SD 2.1 + ESRGAN upscaler...");
+    const modelId = await loadModel({
+        modelSrc: SD_V2_1_1B_Q8_0,
+        modelType: "diffusion",
+        modelConfig: {
+            prediction: "v",
+            upscaler: {
+                type: "esrgan",
+                model_src: esrganModelSrc,
+                tile_size: 128,
+            },
+        },
+        onProgress: (p) => console.log(`Loading: ${p.percentage.toFixed(1)}%`),
+    });
+    console.log(`Model loaded: ${modelId}`);
+    // Source size is intentionally small — each ESRGAN repeat multiplies dimensions.
+    const baseParams = {
+        modelId,
+        prompt,
+        negative_prompt,
+        width: 128,
+        height: 128,
+        steps: 5,
+        cfg_scale: 7.5,
+        seed,
+    };
+    console.log(`\nGenerating ESRGAN x4 upscale: "${prompt}"`);
+    const single = diffusion({ ...baseParams, upscale: true });
+    for await (const { step, totalSteps } of single.progressStream) {
+        process.stdout.write(`\rStep ${step}/${totalSteps}\x1b[K`);
+    }
+    console.log();
+    const singleBuffers = await single.outputs;
+    for (let i = 0; i < singleBuffers.length; i++) {
+        const out = path.join(outputDir, `sd2_esrgan_x4_seed${seed}_${i}.png`);
+        fs.writeFileSync(out, singleBuffers[i]);
+        console.log(`Saved: ${out}`);
+    }
+    console.log("Stats:", await single.stats);
+    console.log("\nGenerating ESRGAN two-pass x16 upscale...");
+    const twoPass = diffusion({ ...baseParams, upscale: { repeats: 2 } });
+    for await (const { step, totalSteps } of twoPass.progressStream) {
+        process.stdout.write(`\rStep ${step}/${totalSteps}\x1b[K`);
+    }
+    console.log();
+    const twoPassBuffers = await twoPass.outputs;
+    for (let i = 0; i < twoPassBuffers.length; i++) {
+        const out = path.join(outputDir, `sd2_esrgan_x16_seed${seed}_${i}.png`);
+        fs.writeFileSync(out, twoPassBuffers[i]);
+        console.log(`Saved: ${out}`);
+    }
+    console.log("Stats:", await twoPass.stats);
+    await unloadModel({ modelId, clearStorage: false });
+    console.log("Done.");
+    process.exit(0);
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/diffusion-txt2vid.d.ts

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

package/dist/examples/diffusion-txt2vid.js

@@ -0,0 +1,81 @@
+import { loadModel, unloadModel, video, WAN2_1_T2V_1_3B_FP16, UMT5_XXL_FP16, WAN_2_1_COMFYUI_REPACKAGED_VAE, } from "@qvac/sdk";
+import fs from "fs";
+import path from "path";
+// Text-to-video with Wan 2.1 T2V 1.3B. Wan uses a split layout:
+// a diffusion model + a UMT5-XXL text encoder + a VAE.
+// This example needs powerful hardware: at least 16 GB of video memory or
+// 20 GB of unified memory.
+const diffusionModelSrc = process.argv[2] || WAN2_1_T2V_1_3B_FP16;
+const t5XxlModelSrc = process.argv[3] || UMT5_XXL_FP16;
+const vaeModelSrc = process.argv[4] || WAN_2_1_COMFYUI_REPACKAGED_VAE;
+// Prompt tip: Wan 1.3B is small and has weak temporal priors. Use motion-
+// explicit verbs and avoid static framing words like "standing", "still",
+// or "portrait" in the positive prompt.
+const prompt = process.argv[5] ||
+    "a colorful bird flapping its wings";
+const outputDir = process.argv[6] || ".";
+try {
+    console.log("Loading Wan 2.1 T2V model (diffusion + UMT5-XXL + VAE)...");
+    const modelId = await loadModel({
+        modelSrc: diffusionModelSrc,
+        modelType: "diffusion",
+        modelConfig: {
+            mode: "video",
+            device: "gpu",
+            threads: 4,
+            t5XxlModelSrc,
+            vaeModelSrc,
+            diffusion_fa: true,
+            offload_to_cpu: true,
+            vae_on_cpu: true,
+            vae_tiling: true,
+        },
+        onProgress: (p) => console.log(`Loading: ${p.percentage.toFixed(1)}%`),
+    });
+    console.log(`Model loaded: ${modelId}`);
+    console.log(`\nGenerating video for: "${prompt}"`);
+    const { progressStream, outputs, stats } = video({
+        modelId,
+        mode: "txt2vid",
+        prompt,
+        negative_prompt: "blurry, low quality, static, jittery, watermark",
+        width: 480,
+        height: 832,
+        // Frame count must satisfy (4*k + 1), k >= 1. Common values at 16 fps:
+        // 17 frames ~= 1.06s (very fast, ~6 min on M3 Ultra Metal)
+        // 33 frames ~= 2.06s (default in this example, ~11 min)
+        // 49 frames ~= 3.06s (~17 min)
+        // 65 frames ~= 4.06s (~22 min)
+        // 81 frames ~= 5.06s (Wan 1.3B native training length, best motion
+        // quality, ~28 min)
+        // Going beyond 81 can degrade quality because it exceeds the model's
+        // positional embeddings.
+        video_frames: 33,
+        fps: 16,
+        steps: 30,
+        cfg_scale: 6.0,
+        // Wan 2.1 T2V needs flow_shift=3.0 for visible motion. Higher values can
+        // make consecutive frames near-identical, which looks like a frozen video.
+        flow_shift: 3.0,
+        seed: 42,
+        vae_tiling: true,
+    });
+    for await (const { step, totalSteps } of progressStream) {
+        process.stdout.write(`\rStep ${step}/${totalSteps}`);
+    }
+    console.log();
+    const buffers = await outputs;
+    for (let i = 0; i < buffers.length; i++) {
+        const outputPath = path.join(outputDir, `wan_t2v_${i}.avi`);
+        fs.writeFileSync(outputPath, buffers[i]);
+        console.log(`Saved: ${outputPath}`);
+    }
+    console.log("\nStats:", await stats);
+    await unloadModel({ modelId, clearStorage: false });
+    console.log("Done.");
+    process.exit(0);
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

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

@@ -4,8 +4,11 @@ console.log(`\n💡 Press Ctrl+C to pause the download (it will resume on restar
 let modelId;
 let cancelled = false;
 try {
-    // Download model with progress tracking and cancellation
-    await downloadAsset({
+    // Download model with progress tracking and cancellation. The
+    // `downloadAsset(...)` call returns a *decorated* promise: the
+    // promise resolves to the modelId, and the same value carries a
+    // synchronous `requestId` field so we can cancel before it settles.
+    const download = downloadAsset({
         assetSrc: LLAMA_3_2_1B_INST_Q4_0,
         onProgress: (progress) => {
             const downloadedMB = (progress.downloaded / 1024 / 1024).toFixed(2);
@@ -18,17 +21,14 @@ try {
                 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
-                    });
-                }
+                void cancel({
+                    requestId: download.requestId,
+                    // clearCache: true, // Uncomment to delete partial file instead of resuming
+                });
             }
         },
     });
+    await download;
     console.log(`\n✅ Model downloaded successfully! Model ID: ${modelId}`);
     console.log("🎯 Download completed without interruption");
     void close();

package/dist/examples/embed-multi-gpu.d.ts

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

package/dist/examples/embed-multi-gpu.js

@@ -0,0 +1,46 @@
+import { loadModel, embed, unloadModel, EMBEDDINGGEMMA_300M_Q8_0 } from "@qvac/sdk";
+// Multi-GPU embedding distributes model layers across multiple GPUs using
+// llama.cpp's built-in split modes. Two strategies are available:
+//
+// - "layer": splits layers and KV cache across GPUs.
+// - "row":   splits layers and KV cache across GPUs, and uses tensor parallelism
+//            where supported.
+//
+// tensorSplit controls the proportion of work assigned to each GPU.
+// "1,1" distributes evenly across two GPUs; "3,1" assigns 75% to GPU 0.
+//
+// mainGpu selects which GPU is used for the entire model when splitMode is
+// "none", and pins the primary device in multi-GPU mode.
+// Accepts an integer device index (0, 1, ...) or "integrated" / "dedicated".
+try {
+    const modelId = await loadModel({
+        modelSrc: EMBEDDINGGEMMA_300M_Q8_0,
+        modelType: "llamacpp-embedding",
+        modelConfig: {
+            splitMode: "layer",
+            tensorSplit: "1,1",
+            mainGpu: 0,
+            gpuLayers: 99,
+            verbosity: 0,
+        },
+    });
+    const texts = [
+        "Multi-GPU embedding distributes layer computation across GPUs.",
+        "Each GPU handles a subset of layers, improving throughput for large models.",
+        "The tensor-split ratio controls how much work each GPU receives.",
+    ];
+    for (const text of texts) {
+        const { embedding, stats } = await embed({ modelId, text });
+        console.log(`Embedded ${text.slice(0, 50)}...`);
+        console.log(`  Dimensions: ${embedding.length}`);
+        if (stats) {
+            console.log(`  Backend: ${stats.backendDevice}, TPS: ${stats.tokensPerSecond?.toFixed(1)}`);
+        }
+    }
+    await unloadModel({ modelId, clearStorage: false });
+    process.exit(0);
+}
+catch (error) {
+    console.error("Error:", error);
+    process.exit(1);
+}

package/dist/examples/llamacpp-multi-gpu.d.ts

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

package/dist/examples/llamacpp-multi-gpu.js

@@ -0,0 +1,57 @@
+import { completion, loadModel, unloadModel, VERBOSITY, LLAMA_3_2_1B_INST_Q4_0 } from "@qvac/sdk";
+// Multi-GPU inference distributes a model across multiple GPUs using llama.cpp's
+// built-in split modes. Two strategies are available:
+//
+// - "layer": splits layers and KV cache across GPUs.
+// - "row":   splits layers and KV cache across GPUs, and uses tensor parallelism
+//            where supported.
+//
+// tensor-split controls the proportion of work assigned to each GPU.
+// "1,1" distributes evenly across two GPUs; "3,1" assigns 75% to GPU 0.
+//
+// Usage:
+//   bun run bare:example dist/examples/llamacpp-multi-gpu.js
+//   bun run bare:example dist/examples/llamacpp-multi-gpu.js '<model-url>'
+const modelSrc = process.argv[2] ?? LLAMA_3_2_1B_INST_Q4_0;
+try {
+    const modelId = await loadModel({
+        modelSrc,
+        modelType: "llm",
+        modelConfig: {
+            "split-mode": "layer",
+            "tensor-split": "1,1",
+            "main-gpu": 0,
+            ctx_size: 4096,
+            gpu_layers: 99,
+            verbosity: VERBOSITY.ERROR,
+        },
+        onProgress: (progress) => {
+            if (progress.shardInfo) {
+                const { shardInfo } = progress;
+                console.log(`Downloading ${shardInfo.shardName} (${shardInfo.currentShard}/${shardInfo.totalShards}) ` +
+                    `— overall: ${shardInfo.overallPercentage.toFixed(1)}%`);
+            }
+            else {
+                console.log(`Downloading: ${progress.percentage.toFixed(1)}%`);
+            }
+        },
+    });
+    const history = [
+        {
+            role: "user",
+            content: "Explain the difference between pipeline and tensor parallelism in one paragraph.",
+        },
+    ];
+    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\nStats:", stats);
+    await unloadModel({ modelId, clearStorage: false });
+    process.exit(0);
+}
+catch (error) {
+    console.error("Error:", error);
+    process.exit(1);
+}

package/dist/examples/plugins.js

@@ -10,7 +10,7 @@
  *   3. Embeddings        -> fails (plugin not selected)
  *
  */
-import { execSync } from "child_process";
+import { bundleSdk } from "../commands/index.js";
 import { existsSync, rmSync } from "fs";
 import path from "path";
 const configDir = import.meta.dirname ?? process.cwd();
@@ -23,14 +23,10 @@ console.log(`⚠️  This example will generate a worker bundle in ${qvacOutputD
 console.log("   If you have an existing qvac/ folder with bundled files, they will be overwritten and removed.\n");
 console.log("🔨 Generating worker bundle from plugins config...\n");
 try {
-    execSync(`npx @qvac/cli bundle sdk --config "${configPath}" --quiet`, {
-        cwd: projectRoot,
-        stdio: "inherit",
-    });
+    await bundleSdk({ projectRoot, configPath, quiet: true });
 }
 catch (error) {
-    console.error("❌ Failed to generate worker bundle. Ensure @qvac/cli is installed:");
-    console.error("   npm install -D @qvac/cli");
+    console.error("❌ Failed to generate worker bundle.");
     console.error("❌ Error:", error);
     process.exit(1);
 }

package/dist/examples/rag/rag-hyperdb/cancellation.js

@@ -31,24 +31,27 @@ try {
     console.log(`📄 Processing ${documents.length} documents...\n`);
     let progressCount = 0;
     let cancelled = false;
+    // Capture the decorated promise so we can cancel by `requestId` (the
+    // primary cancel path). For a "cancel everything RAG on this model"
+    // sweep, use `cancel({ modelId, kind: "rag" })` instead.
+    const ingest = ragIngest({
+        modelId,
+        workspace: WORKSPACE,
+        documents,
+        progressInterval: 50,
+        onProgress: (stage, current, total) => {
+            progressCount++;
+            const pct = total > 0 ? Math.round((current / total) * 100) : 0;
+            console.log(`   [${stage}] ${current}/${total} (${pct}%)`);
+            if (!cancelled && stage === "embedding" && current > 10) {
+                console.log("\n🛑 Triggering cancellation...\n");
+                cancelled = true;
+                void cancel({ requestId: ingest.requestId });
+            }
+        },
+    });
     try {
-        await ragIngest({
-            modelId,
-            workspace: WORKSPACE,
-            documents,
-            progressInterval: 50,
-            onProgress: (stage, current, total) => {
-                progressCount++;
-                const pct = total > 0 ? Math.round((current / total) * 100) : 0;
-                console.log(`   [${stage}] ${current}/${total} (${pct}%)`);
-                // Cancel during embedding stage after a few updates
-                if (!cancelled && stage === "embedding" && current > 10) {
-                    console.log("\n🛑 Triggering cancellation...\n");
-                    cancelled = true;
-                    void cancel({ operation: "rag", workspace: WORKSPACE });
-                }
-            },
-        });
+        await ingest;
         console.log("\n⚠️  Ingest completed (cancellation didn't interrupt in time)");
     }
     catch (error) {

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

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

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

@@ -0,0 +1,73 @@
+/**
+ * Tool-calling example using the Gemma4 native dialect.
+ *
+ * Gemma4 emits tool calls in a JS-literal format with custom quote tokens:
+ *   <|tool_call>call:NAME{key:<|"|>val<|"|>,...}<tool_call|>
+ *
+ * Reasoning output (thinking) is emitted inside <|channel>thought...<channel|>
+ * frames, which are stripped from contentDelta and forwarded as thinkingDelta
+ * when captureThinking is true.
+ *
+ * The dialect is auto-detected from the model name/path when the file name
+ * contains "gemma4" or "gemma-4". Pass toolDialect: "gemma4" explicitly to
+ * completion() if auto-detection does not pick it up for a given file name.
+ *
+ * Usage:
+ *   bun run bare:example dist/examples/tools/llamacpp-tools-gemma4.js <model-url>
+ */
+import { completion, loadModel, unloadModel, GEMMA4_2B_MULTIMODAL_Q4_K_M, } from "@qvac/sdk";
+import { tools, mockExecute } from "./shared.js";
+const modelSrc = process.argv[2] ?? GEMMA4_2B_MULTIMODAL_Q4_K_M;
+let modelId;
+try {
+    modelId = await loadModel({
+        modelSrc,
+        modelType: "llm",
+        modelConfig: { ctx_size: 4096, tools: true },
+        onProgress: (progress) => console.log(`Loading: ${progress.percentage.toFixed(1)}%`),
+    });
+    console.log(`Model loaded: ${modelId}`);
+    const history = [
+        {
+            role: "system",
+            content: "You are a helpful assistant that can call tools to look up weather and horoscopes.",
+        },
+        {
+            role: "user",
+            content: "What's the weather in Tokyo and my horoscope for Aquarius?",
+        },
+    ];
+    const result = completion({ modelId, history, stream: true, tools });
+    const tokensTask = (async () => {
+        for await (const token of result.tokenStream) {
+            process.stdout.write(token);
+        }
+    })();
+    const toolsTask = (async () => {
+        for await (const evt of result.toolCallStream) {
+            if (evt.type === "toolCall") {
+                console.log(`\n-> ${evt.call.name}(${JSON.stringify(evt.call.arguments)})`);
+            }
+        }
+    })();
+    await Promise.all([tokensTask, toolsTask]);
+    const toolCalls = await result.toolCalls;
+    console.log("\n\nFinal tool calls:");
+    if (toolCalls.length > 0) {
+        for (const call of toolCalls) {
+            console.log(`  - ${call.name}(${JSON.stringify(call.arguments)})`);
+            const toolResult = mockExecute(call.name, call.arguments);
+            console.log(`    result: ${toolResult}`);
+        }
+    }
+    else {
+        console.log("  (none)");
+    }
+    await unloadModel({ modelId, clearStorage: false });
+}
+catch (error) {
+    console.error("Error:", error);
+    if (modelId)
+        await unloadModel({ modelId, clearStorage: false }).catch(() => { });
+    process.exit(1);
+}

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

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

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

@@ -0,0 +1,69 @@
+/**
+ * Tool-calling example using the Qwen3.5 dialect.
+ *
+ * Qwen3.5 emits tool calls in a Pythonic-XML format:
+ *   <tool_call><function=NAME><parameter=KEY>VALUE</parameter></function></tool_call>
+ *
+ * The dialect is auto-detected from the model name/path when the model file
+ * contains "qwen3.5", "qwen3-5", "qwen3.6", or "qwen3-6". Pass
+ * toolDialect: "qwen35" explicitly if auto-detection does not pick it up.
+ *
+ * Usage:
+ *   bun run bare:example dist/examples/tools/llamacpp-tools-qwen35.js <model-url>
+ */
+import { completion, loadModel, unloadModel, QWEN3_5_0_8B_MULTIMODAL_Q8_0, } from "@qvac/sdk";
+import { tools, mockExecute } from "./shared.js";
+const modelSrc = process.argv[2] ?? QWEN3_5_0_8B_MULTIMODAL_Q8_0;
+let modelId;
+try {
+    modelId = await loadModel({
+        modelSrc,
+        modelType: "llm",
+        modelConfig: { ctx_size: 4096, tools: true },
+        onProgress: (progress) => console.log(`Loading: ${progress.percentage.toFixed(1)}%`),
+    });
+    console.log(`Model loaded: ${modelId}`);
+    const history = [
+        {
+            role: "system",
+            content: "You are a helpful assistant that can call tools to look up weather and horoscopes.",
+        },
+        {
+            role: "user",
+            content: "What's the weather in Tokyo and my horoscope for Aquarius?",
+        },
+    ];
+    const result = completion({ modelId, history, stream: true, tools });
+    const tokensTask = (async () => {
+        for await (const token of result.tokenStream) {
+            process.stdout.write(token);
+        }
+    })();
+    const toolsTask = (async () => {
+        for await (const evt of result.toolCallStream) {
+            if (evt.type === "toolCall") {
+                console.log(`\n-> ${evt.call.name}(${JSON.stringify(evt.call.arguments)})`);
+            }
+        }
+    })();
+    await Promise.all([tokensTask, toolsTask]);
+    const toolCalls = await result.toolCalls;
+    console.log("\n\nFinal tool calls:");
+    if (toolCalls.length > 0) {
+        for (const call of toolCalls) {
+            console.log(`  - ${call.name}(${JSON.stringify(call.arguments)})`);
+            const toolResult = mockExecute(call.name, call.arguments);
+            console.log(`    result: ${toolResult}`);
+        }
+    }
+    else {
+        console.log("  (none)");
+    }
+    await unloadModel({ modelId, clearStorage: false });
+}
+catch (error) {
+    console.error("Error:", error);
+    if (modelId)
+        await unloadModel({ modelId, clearStorage: false }).catch(() => { });
+    process.exit(1);
+}

package/dist/examples/transcription/parakeet-ctc-filesystem.js

@@ -1,24 +1,30 @@
-import { loadModel, unloadModel, transcribe, PARAKEET_CTC_FP32, PARAKEET_CTC_TOKENIZER, } from "@qvac/sdk";
+/**
+ * Parakeet CTC transcription from a WAV file.
+ *
+ * Usage:
+ *   bun run examples/transcription/parakeet-ctc-filesystem.ts <wav-file> [parakeet-ctc-gguf]
+ *
+ * Loads a single GGUF checkpoint (`PARAKEET_CTC_0_6B_Q8_0` by default) and
+ * transcribes the file with the batch `transcribe` API. Omit the model
+ * argument to use the registry constant.
+ *
+ * Audio should be 16 kHz mono PCM in a WAV container.
+ */
+import { loadModel, unloadModel, transcribe, PARAKEET_CTC_0_6B_Q8_0, } from "@qvac/sdk";
 const args = process.argv.slice(2);
 if (!args[0]) {
     console.error("Usage: bun run examples/transcription/parakeet-ctc-filesystem.ts <wav-file> " +
-        "[model.onnx] [tokenizer.json]");
-    console.error("\nIf model paths are omitted, defaults to registry models.");
+        "[parakeet-ctc-gguf]");
+    console.error("\nIf the model path is omitted, defaults to the registry model.");
     process.exit(1);
 }
 const audioFilePath = args[0];
-const parakeetCtcModelSrc = args[1] ?? PARAKEET_CTC_FP32;
-const parakeetTokenizerSrc = args[2] ?? PARAKEET_CTC_TOKENIZER;
+const parakeetModelSrc = args[1] ?? PARAKEET_CTC_0_6B_Q8_0;
 try {
     console.log("Loading Parakeet CTC model...");
     const modelId = await loadModel({
-        modelSrc: parakeetCtcModelSrc,
+        modelSrc: parakeetModelSrc,
         modelType: "parakeet",
-        modelConfig: {
-            modelType: "ctc",
-            parakeetCtcModelSrc,
-            parakeetTokenizerSrc,
-        },
         onProgress: (progress) => {
             console.log(`Download progress: ${progress.percentage.toFixed(1)}%`);
         },
@@ -33,6 +39,6 @@ try {
     console.log("Done");
 }
 catch (error) {
-    console.error("Error:", error);
+    console.error("❌ Error:", error);
     process.exit(1);
 }

package/dist/examples/transcription/parakeet-microphone-record.js

@@ -1,14 +1,15 @@
 /**
- * Microphone → Parakeet transcription using chunked `transcribe` calls.
+ * Microphone → Parakeet batch transcription (chunked `transcribe`).
  *
- * Usage: bun run examples/transcription/parakeet-microphone-record.ts
+ * Usage:
+ *   bun run examples/transcription/parakeet-microphone-record.ts
  *
- * Captures 3-second audio chunks from the microphone and sends each to the
- * batch `transcribe` API. Press Ctrl+C to quit.
+ * Captures 3 s s16le chunks from the microphone and sends each to `transcribe`
+ * with the TDT model. Press Ctrl+C to stop.
  *
  * Requirements: FFmpeg installed, microphone access.
  */
-import { loadModel, unloadModel, transcribe, PARAKEET_TDT_ENCODER_FP32, PARAKEET_TDT_DECODER_FP32, PARAKEET_TDT_VOCAB, PARAKEET_TDT_PREPROCESSOR_FP32, } from "@qvac/sdk";
+import { loadModel, unloadModel, transcribe, PARAKEET_TDT_0_6B_V3_Q8_0, } from "@qvac/sdk";
 import { spawnSync } from "child_process";
 import { startMicrophone } from "../audio/mic-input";
 const SAMPLE_RATE = 16000;
@@ -27,14 +28,8 @@ catch {
 }
 console.log("Loading Parakeet model...");
 const modelId = await loadModel({
-    modelSrc: PARAKEET_TDT_ENCODER_FP32,
+    modelSrc: PARAKEET_TDT_0_6B_V3_Q8_0,
     modelType: "parakeet",
-    modelConfig: {
-        parakeetEncoderSrc: PARAKEET_TDT_ENCODER_FP32,
-        parakeetDecoderSrc: PARAKEET_TDT_DECODER_FP32,
-        parakeetVocabSrc: PARAKEET_TDT_VOCAB,
-        parakeetPreprocessorSrc: PARAKEET_TDT_PREPROCESSOR_FP32,
-    },
     onProgress: (p) => console.log(`Download: ${p.percentage.toFixed(1)}%`),
 });
 console.log("Model loaded.\n");

package/dist/examples/transcription/parakeet-microphone-stream.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parakeet-microphone-stream.d.ts.map