@qvac/sdk 0.7.1 → 0.8.1

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

@@ -1,11 +1,14 @@
-import { requestSchema, responseSchema, } from "../../schemas/index.js";
+import { requestSchema, responseSchema, PROFILING_TRAILER_KEY, } 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";
+import { nowMs, shouldProfile, shouldIncludeServerBreakdown, generateId as createProfileId, createProfilingMeta, createProfilingDisabledMeta, injectProfilingMetaIntoObject, extractProfilingMeta, stripProfilingMeta, recordFailure, } from "../../profiling/index.js";
+import { createClientTimings, createClientStreamTimings, recordClientEvents, recordClientStreamEvents, cacheConnectionTime, flushConnectionTime, resetConnectionTracking, } from "./profiling/index.js";
 const logger = getClientLogger();
 let rpcInstance = null;
 let commandCounter = 0;
+let firstConnectionPending = true;
 function getNextCommandId() {
     commandCounter = (commandCounter + 1) % Number.MAX_SAFE_INTEGER;
     return commandCounter;
@@ -17,16 +20,43 @@ function checkAndThrowError(response) {
 }
 async function getRPCInstance() {
     if (rpcInstance)
-        return rpcInstance;
-    rpcInstance = await getRPC();
-    return rpcInstance;
+        return { rpc: await rpcInstance };
+    const connectionStart = firstConnectionPending ? nowMs() : null;
+    rpcInstance = getRPC();
+    const rpc = await rpcInstance;
+    if (connectionStart !== null && firstConnectionPending) {
+        firstConnectionPending = false;
+        return { rpc, connectionMs: nowMs() - connectionStart };
+    }
+    return { rpc };
+}
+async function prepareRPCContext(requestType, perCallProfiling, rpc) {
+    const rpcResult = rpc ? { rpc } : await getRPCInstance();
+    const profilingEnabled = shouldProfile(requestType, perCallProfiling);
+    const signalDisable = perCallProfiling?.enabled === false;
+    if (rpcResult.connectionMs !== undefined) {
+        cacheConnectionTime(rpcResult.connectionMs);
+    }
+    if (profilingEnabled) {
+        flushConnectionTime();
+    }
+    return { rpc: rpcResult.rpc, profilingEnabled, signalDisable };
+}
+export async function send(request, options, rpc) {
+    const ctx = await prepareRPCContext(request.type, options?.profiling, rpc);
+    if (!ctx.profilingEnabled) {
+        return sendBase(request, ctx.rpc, options, ctx.signalDisable);
+    }
+    return sendProfiled(request, ctx.rpc, options);
 }
-export async function send(request, rpc, options) {
+async function sendBase(request, rpc, options, signalDisable = false) {
     const parsedRequest = requestSchema.parse(request);
-    const rpcInstance = rpc || (await getRPCInstance());
-    const req = rpcInstance.request(getNextCommandId());
+    const req = rpc.request(getNextCommandId());
     logger.debug("RPC Client sending:", summarizeRequest(request));
-    const payload = JSON.stringify(parsedRequest);
+    const payloadObj = signalDisable
+        ? injectProfilingMetaIntoObject(parsedRequest, createProfilingDisabledMeta())
+        : parsedRequest;
+    const payload = JSON.stringify(payloadObj);
     req.send(payload, "utf-8");
     const response = await withTimeout(req.reply("utf-8"), options?.timeout);
     const resPayload = responseSchema.parse(JSON.parse(response?.toString() || "{}"));
@@ -34,12 +64,69 @@ export async function send(request, rpc, options) {
     checkAndThrowError(resPayload);
     return resPayload;
 }
-export async function* stream(request, rpc, options = {}) {
+async function sendProfiled(request, rpc, options) {
+    const requestType = request.type;
+    const profileId = createProfileId();
+    const includeServer = shouldIncludeServerBreakdown(options?.profiling);
+    const timings = createClientTimings(profileId, requestType);
+    try {
+        const zodStart = nowMs();
+        const parsedRequest = requestSchema.parse(request);
+        timings.requestZodValidationMs = nowMs() - zodStart;
+        const req = rpc.request(getNextCommandId());
+        logger.debug("RPC Client sending:", summarizeRequest(request));
+        const profilingMeta = createProfilingMeta(profileId, includeServer);
+        const requestWithMeta = injectProfilingMetaIntoObject(parsedRequest, profilingMeta);
+        const stringifyStart = nowMs();
+        const payload = JSON.stringify(requestWithMeta);
+        timings.requestStringifyMs = nowMs() - stringifyStart;
+        timings.sendStart = nowMs();
+        req.send(payload, "utf-8");
+        const response = await withTimeout(req.reply("utf-8"), options?.timeout);
+        timings.firstResponseAt = nowMs();
+        const parseStart = nowMs();
+        const rawParsed = JSON.parse(response?.toString() || "{}");
+        timings.responseJsonParseMs = nowMs() - parseStart;
+        const responseMeta = extractProfilingMeta(rawParsed);
+        const cleanPayload = stripProfilingMeta(rawParsed);
+        const zodValidateStart = nowMs();
+        const resPayload = responseSchema.parse(cleanPayload);
+        timings.responseZodValidationMs = nowMs() - zodValidateStart;
+        timings.requestEnd = nowMs();
+        logger.debug("ResPayload", { type: resPayload.type });
+        recordClientEvents(timings, responseMeta);
+        checkAndThrowError(resPayload);
+        return resPayload;
+    }
+    catch (error) {
+        if (timings.requestEnd === undefined) {
+            const base = {
+                ts: nowMs(),
+                op: timings.requestType,
+                kind: "rpc",
+                profileId: timings.profileId,
+            };
+            recordFailure(base, timings.requestStart, error);
+        }
+        throw error;
+    }
+}
+export async function* stream(request, options = {}, rpc) {
+    const ctx = await prepareRPCContext(request.type, options?.profiling, rpc);
+    if (!ctx.profilingEnabled) {
+        yield* streamBase(request, ctx.rpc, options, ctx.signalDisable);
+        return;
+    }
+    yield* streamProfiled(request, ctx.rpc, options);
+}
+async function* streamBase(request, rpc, options = {}, signalDisable = false) {
     const parsedRequest = requestSchema.parse(request);
-    const rpcInstance = rpc || (await getRPCInstance());
-    const req = rpcInstance.request(getNextCommandId());
+    const req = rpc.request(getNextCommandId());
     logger.debug("RPC Client streaming:", summarizeRequest(request));
-    req.send(JSON.stringify(parsedRequest), "utf-8");
+    const payloadObj = signalDisable
+        ? injectProfilingMetaIntoObject(parsedRequest, createProfilingDisabledMeta())
+        : parsedRequest;
+    req.send(JSON.stringify(payloadObj), "utf-8");
     const responseStream = req.createResponseStream({ encoding: "utf-8" });
     let buffer = "";
     async function* processStream() {
@@ -62,9 +149,84 @@ export async function* stream(request, rpc, options = {}) {
         }
     }
 }
+async function* streamProfiled(request, rpc, options = {}) {
+    const requestType = request.type;
+    const profileId = createProfileId();
+    const includeServer = shouldIncludeServerBreakdown(options?.profiling);
+    const timings = createClientStreamTimings(profileId, requestType);
+    let profilingMeta = undefined;
+    try {
+        const zodStart = nowMs();
+        const parsedRequest = requestSchema.parse(request);
+        timings.requestZodValidationMs = nowMs() - zodStart;
+        const req = rpc.request(getNextCommandId());
+        logger.debug("RPC Client streaming:", summarizeRequest(request));
+        const requestMeta = createProfilingMeta(profileId, includeServer);
+        const requestWithMeta = injectProfilingMetaIntoObject(parsedRequest, requestMeta);
+        const stringifyStart = nowMs();
+        const payload = JSON.stringify(requestWithMeta);
+        timings.requestStringifyMs = nowMs() - stringifyStart;
+        timings.sendStart = nowMs();
+        req.send(payload, "utf-8");
+        const responseStream = req.createResponseStream({ encoding: "utf-8" });
+        let buffer = "";
+        async function* processStream() {
+            for await (const chunk of responseStream) {
+                yield chunk;
+            }
+        }
+        const streamWithTimeout = withTimeoutStream(processStream(), options?.timeout);
+        for await (const chunk of streamWithTimeout) {
+            const chunkTime = nowMs();
+            if (timings.firstChunkAt === undefined) {
+                timings.firstChunkAt = chunkTime;
+            }
+            timings.lastChunkAt = chunkTime;
+            buffer += chunk.toString();
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+                if (line.trim()) {
+                    const rawParsed = JSON.parse(line);
+                    const chunkMeta = extractProfilingMeta(rawParsed);
+                    if (chunkMeta) {
+                        profilingMeta = chunkMeta;
+                    }
+                    if (rawParsed[PROFILING_TRAILER_KEY] === true)
+                        continue;
+                    const cleanPayload = stripProfilingMeta(rawParsed);
+                    const response = responseSchema.parse(cleanPayload);
+                    timings.chunkCount++;
+                    checkAndThrowError(response);
+                    yield response;
+                }
+            }
+        }
+    }
+    catch (error) {
+        if (timings.requestEnd === undefined) {
+            const base = {
+                ts: nowMs(),
+                op: timings.requestType,
+                kind: "rpc",
+                profileId: timings.profileId,
+            };
+            recordFailure(base, timings.requestStart, error);
+        }
+        throw error;
+    }
+    finally {
+        if (timings.chunkCount > 0) {
+            timings.requestEnd = nowMs();
+            recordClientStreamEvents(timings, profilingMeta);
+        }
+    }
+}
 export async function close() {
     if (!rpcInstance)
         return;
     rpcInstance = null;
+    firstConnectionPending = true;
+    resetConnectionTracking();
     await closeRPC();
 }

package/dist/examples/delegated-inference/consumer-profiled.d.ts

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

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

@@ -0,0 +1,67 @@
+import { close, completion, LLAMA_3_2_1B_INST_Q4_0, loadModel, profiler, } from "@qvac/sdk";
+const topicHex = process.argv[2];
+if (!topicHex) {
+    console.error("❌ Usage: bun run consumer-profiled.ts <topic> <publicKey>");
+    process.exit(1);
+}
+const providerPublicKey = process.argv[3];
+if (!providerPublicKey) {
+    console.error("❌ Usage: bun run consumer-profiled.ts <topic> <publicKey>");
+    process.exit(1);
+}
+try {
+    profiler.enable({ mode: "verbose", includeServerBreakdown: true });
+    console.log("✓ Profiler enabled");
+    console.log(`\n📡 Topic: ${topicHex}`);
+    console.log(`🔑 Provider: ${providerPublicKey}\n`);
+    console.log("→ Loading model (delegated, unary)...");
+    const modelId = await loadModel({
+        modelSrc: LLAMA_3_2_1B_INST_Q4_0,
+        modelType: "llm",
+        delegate: {
+            topic: topicHex,
+            providerPublicKey,
+            timeout: 30_000,
+        },
+    });
+    console.log(`✓ Model loaded: ${modelId}\n`);
+    console.log("→ Running completion (delegated, streamed)...");
+    const response = completion({
+        modelId,
+        history: [{ role: "user", content: "Say hello in exactly 5 words." }],
+        stream: true,
+    });
+    process.stdout.write("  Response: ");
+    for await (const token of response.tokenStream) {
+        process.stdout.write(token);
+    }
+    await response.stats;
+    console.log("\n✓ Completion done\n");
+    console.log("=== Profiler Summary ===");
+    console.log(profiler.exportSummary());
+    console.log("=== Profiler Table ===");
+    console.log(profiler.exportTable());
+    // Look for delegation-specific metrics
+    const json = profiler.exportJSON();
+    const delegationMetrics = Object.keys(json.aggregates).filter((k) => k.includes("delegation") || k.includes("delegated"));
+    if (delegationMetrics.length > 0) {
+        console.log("=== Delegation Metrics ===");
+        for (const key of delegationMetrics) {
+            const agg = json.aggregates[key];
+            if (agg) {
+                console.log(`  ${key}: ${agg.avg.toFixed(2)}ms (count: ${agg.count})`);
+            }
+        }
+    }
+    else {
+        console.log("⚠️  No delegation-specific metrics found");
+        console.log("    (delegation profiling may need to be triggered)");
+    }
+    profiler.disable();
+    void close();
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    profiler.disable();
+    process.exit(1);
+}

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

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

package/dist/examples/llamacpp-multimodal.js

@@ -10,9 +10,9 @@ try {
     const modelId = await loadModel({
         modelSrc: SMOLVLM2_500M_MULTIMODAL_Q8_0,
         modelType: "llm",
-        projectionModelSrc: MMPROJ_SMOLVLM2_500M_MULTIMODAL_Q8_0,
         modelConfig: {
             ctx_size: 1024,
+            projectionModelSrc: MMPROJ_SMOLVLM2_500M_MULTIMODAL_Q8_0,
         },
         onProgress: (progress) => {
             console.log(`Loading: ${progress.percentage.toFixed(1)}%`);

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

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

package/dist/examples/parallel-download.js

@@ -1,18 +1,50 @@
-import { LLAMA_3_2_1B_INST_Q4_0, downloadAsset, WHISPER_TINY, close, } from "@qvac/sdk";
+import { LLAMA_3_2_1B_INST_Q4_0, WHISPER_TINY, VAD_SILERO_5_1_2, GTE_LARGE_FP16, downloadAsset, close, } from "@qvac/sdk";
+function now() {
+    return Date.now();
+}
+const assets = [
+    { name: "Llama 3.2 1B", src: LLAMA_3_2_1B_INST_Q4_0 },
+    { name: "Whisper Tiny", src: WHISPER_TINY },
+    { name: "VAD Silero", src: VAD_SILERO_5_1_2 },
+    { name: "GTE Large FP16", src: GTE_LARGE_FP16 },
+];
+const timers = {};
+console.log(`\n=== Parallel Download (${assets.length} assets) ===\n`);
+const wallStart = now();
 try {
-    const llamaDownloadPromise = downloadAsset({
-        assetSrc: LLAMA_3_2_1B_INST_Q4_0,
-        onProgress: (progress) => {
-            console.log("💬 Llama progress:", progress);
-        },
-    });
-    const whisperDownloadPromise = downloadAsset({
-        assetSrc: WHISPER_TINY,
-        onProgress: (progress) => {
-            console.log("🔊 Whisper progress:", progress);
-        },
+    const promises = assets.map((asset) => {
+        timers[asset.name] = { start: now() };
+        return downloadAsset({
+            assetSrc: asset.src,
+            onProgress: (progress) => {
+                const t = timers[asset.name];
+                if (t.firstProgress == null) {
+                    t.firstProgress = now();
+                    console.log(`[${asset.name}] first progress at ${((t.firstProgress - wallStart) / 1000).toFixed(1)}s — ${progress.percentage}%`);
+                }
+                if (progress.percentage === 100 && t.end == null) {
+                    t.end = now();
+                    console.log(`[${asset.name}] done at ${((t.end - wallStart) / 1000).toFixed(1)}s`);
+                }
+            },
+        });
     });
-    await Promise.all([llamaDownloadPromise, whisperDownloadPromise]);
+    const results = await Promise.allSettled(promises);
+    const wallEnd = now();
+    console.log(`\n=== Results ===\n`);
+    for (let i = 0; i < assets.length; i++) {
+        const asset = assets[i];
+        const result = results[i];
+        const t = timers[asset.name];
+        const status = result.status === "fulfilled" ? "OK" : "FAILED";
+        const reason = result.status === "rejected" ? ` — ${result.reason}` : "";
+        const timeToFirst = t.firstProgress != null
+            ? `${((t.firstProgress - t.start) / 1000).toFixed(1)}s`
+            : "N/A";
+        const total = t.end != null ? `${((t.end - t.start) / 1000).toFixed(1)}s` : "N/A";
+        console.log(`${status} ${asset.name}: first-progress=${timeToFirst}, total=${total}${reason}`);
+    }
+    console.log(`\nWall time: ${((wallEnd - wallStart) / 1000).toFixed(1)}s`);
     void close();
 }
 catch (error) {

package/dist/examples/profiling/basic.d.ts

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

package/dist/examples/profiling/basic.js

@@ -0,0 +1,71 @@
+import { completion, loadModel, unloadModel, LLAMA_3_2_1B_INST_Q4_0, profiler, } from "@qvac/sdk";
+try {
+    // Enable profiling globally
+    profiler.enable({
+        mode: "verbose",
+        includeServerBreakdown: true,
+    });
+    console.log("Profiler enabled:", profiler.isEnabled());
+    const modelId = await loadModel({
+        modelSrc: LLAMA_3_2_1B_INST_Q4_0,
+        modelType: "llm",
+        onProgress: (p) => console.log(`  ${p.percentage.toFixed(1)}%`),
+    });
+    console.log("Model loaded:", modelId);
+    console.log("\n→ Running completion...");
+    const result = completion({
+        modelId,
+        history: [{ role: "user", content: "Say hello in one sentence." }],
+        stream: true,
+    });
+    for await (const token of result.tokenStream) {
+        process.stdout.write(token);
+    }
+    console.log();
+    await unloadModel({ modelId });
+    // Export profiling data
+    console.log("\n=== Profiler Summary ===");
+    console.log(profiler.exportSummary());
+    console.log("\n=== Profiler Table ===");
+    console.log(profiler.exportTable());
+    const json = profiler.exportJSON();
+    console.log("\n=== Load Model Metrics ===");
+    // Filter for operation-level event (kind: "handler"), not RPC phase events
+    const loadModelEvent = json.recentEvents?.find((e) => e.op === "loadModel" && e.kind === "handler");
+    if (loadModelEvent) {
+        const tags = loadModelEvent.tags ?? {};
+        const gauges = loadModelEvent.gauges ?? {};
+        console.log("  sourceType:", tags["sourceType"] ?? "(not set)");
+        console.log("  cacheHit:", tags["cacheHit"] ?? "(not set)");
+        console.log("  totalLoadTime:", gauges["totalLoadTime"], "ms");
+        console.log("  modelInitializationTime:", gauges["modelInitializationTime"], "ms");
+        if (tags["cacheHit"] !== "true") {
+            console.log("  downloadTime:", gauges["downloadTime"] ?? "(cached)", "ms");
+            console.log("  totalBytesDownloaded:", gauges["totalBytesDownloaded"] ?? "(cached)");
+            console.log("  downloadSpeedBps:", gauges["downloadSpeedBps"] ?? "(cached)");
+        }
+        else {
+            console.log("  (download metrics omitted - cache hit)");
+        }
+        if (gauges["checksumValidationTime"] !== undefined) {
+            console.log("  checksumValidationTime:", gauges["checksumValidationTime"], "ms");
+        }
+    }
+    else {
+        console.log("  (no loadModel handler event captured)");
+        // Debug: show what ops are available
+        const ops = [...new Set(json.recentEvents?.map((e) => `${e.op}:${e.kind}`) ?? [])];
+        console.log("  Available ops:", ops.join(", "));
+    }
+    console.log("\n=== Profiler JSON (structure) ===");
+    console.log("  aggregates:", Object.keys(json.aggregates).length, "metrics");
+    console.log("  recentEvents:", json.recentEvents?.length ?? 0, "events");
+    console.log("  config:", json.config);
+    // Disable profiling
+    profiler.disable();
+    console.log("\nProfiler disabled:", !profiler.isEnabled());
+}
+catch (error) {
+    console.error("Error:", error);
+    process.exit(1);
+}

package/dist/examples/profiling/per-call.d.ts

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

package/dist/examples/profiling/per-call.js

@@ -0,0 +1,30 @@
+import { embed, loadModel, unloadModel, GTE_LARGE_FP16, profiler, } from "@qvac/sdk";
+try {
+    profiler.disable();
+    console.log("Profiler globally enabled:", profiler.isEnabled());
+    const modelId = await loadModel({
+        modelSrc: GTE_LARGE_FP16,
+        modelType: "embeddings",
+        onProgress: (p) => console.log(`  ${p.percentage.toFixed(1)}%`),
+    });
+    console.log("Model loaded:", modelId);
+    console.log("\n=== Embed with per-call profiling ===");
+    const embedding1 = await embed({ modelId, text: "Profile this specific call" }, { profiling: { enabled: true, includeServerBreakdown: true } });
+    console.log("Embedding dimensions:", embedding1.length);
+    console.log("\n=== Embed without profiling ===");
+    const embedding2 = await embed({
+        modelId,
+        text: "This call is not profiled",
+    });
+    console.log("Embedding dimensions:", embedding2.length);
+    console.log("\n=== Embed with profiling explicitly disabled ===");
+    const embedding3 = await embed({ modelId, text: "Profiling explicitly disabled for this call" }, { profiling: { enabled: false } });
+    console.log("Embedding dimensions:", embedding3.length);
+    await unloadModel({ modelId });
+    console.log("\n=== Profiler Summary (per-call data only) ===");
+    console.log(profiler.exportSummary());
+}
+catch (error) {
+    console.error("Error:", error);
+    process.exit(1);
+}

package/dist/examples/seed-p2p.d.ts

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

package/dist/examples/transcription/parakeet-ctc-filesystem.d.ts

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

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

@@ -0,0 +1,40 @@
+import { loadModel, unloadModel, transcribe, PARAKEET_CTC_FP32, PARAKEET_CTC_DATA_FP32, PARAKEET_CTC_TOKENIZER, } 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] [model.onnx_data] [tokenizer.json]");
+    console.error("\nIf model paths are omitted, defaults to registry models.");
+    process.exit(1);
+}
+const audioFilePath = args[0];
+const parakeetCtcModelSrc = args[1] ?? PARAKEET_CTC_FP32;
+const parakeetCtcModelDataSrc = args[2] ?? PARAKEET_CTC_DATA_FP32;
+const parakeetTokenizerSrc = args[3] ?? PARAKEET_CTC_TOKENIZER;
+try {
+    console.log("Loading Parakeet CTC model...");
+    const modelId = await loadModel({
+        modelSrc: parakeetCtcModelSrc,
+        modelType: "parakeet",
+        modelConfig: {
+            modelType: "ctc",
+            parakeetCtcModelSrc,
+            parakeetCtcModelDataSrc,
+            parakeetTokenizerSrc,
+        },
+        onProgress: (progress) => {
+            console.log(`Download progress: ${progress.percentage.toFixed(1)}%`);
+        },
+    });
+    console.log(`Parakeet CTC model loaded with ID: ${modelId}`);
+    console.log("Transcribing audio...");
+    const text = await transcribe({ modelId, audioChunk: audioFilePath });
+    console.log("Transcription result:");
+    console.log(text);
+    console.log("Unloading model...");
+    await unloadModel({ modelId });
+    console.log("Done");
+}
+catch (error) {
+    console.error("Error:", error);
+    process.exit(1);
+}

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

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

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

@@ -0,0 +1,95 @@
+import { loadModel, unloadModel, transcribeStream, PARAKEET_TDT_ENCODER_FP32, PARAKEET_TDT_ENCODER_DATA_FP32, PARAKEET_TDT_DECODER_FP32, PARAKEET_TDT_VOCAB, PARAKEET_TDT_PREPROCESSOR_FP32, } from "@qvac/sdk";
+import { spawn, spawnSync } from "child_process";
+import { platform } from "os";
+function checkFFmpeg() {
+    const result = spawnSync("ffmpeg", ["-version"], { stdio: "ignore" });
+    if (result.error || result.status !== 0) {
+        throw new Error("FFmpeg is required but not found in PATH.");
+    }
+}
+function getAudioDevice() {
+    switch (platform()) {
+        case "darwin":
+            return ":0";
+        case "linux":
+            return "default";
+        case "win32":
+            // Change as per your system
+            return "audio=@device_cm_{33D9A762-90C8-11D0-BD43-00A0C911CE86}\\wave_{58C07110-A4FD-4FF8-BA10-5A3C14389F71}";
+        default:
+            throw new Error(`Unsupported platform: ${platform()}`);
+    }
+}
+function getAudioInputArgs() {
+    switch (platform()) {
+        case "darwin":
+            return ["-f", "avfoundation", "-i", getAudioDevice()];
+        case "linux":
+            return ["-f", "pulse", "-i", getAudioDevice()];
+        case "win32":
+            return ["-f", "dshow", "-i", getAudioDevice()];
+        default:
+            throw new Error(`Unsupported platform: ${platform()}`);
+    }
+}
+checkFFmpeg();
+console.log("Loading Parakeet model...");
+const modelId = await loadModel({
+    modelSrc: PARAKEET_TDT_ENCODER_FP32,
+    modelType: "parakeet",
+    modelConfig: {
+        parakeetEncoderSrc: PARAKEET_TDT_ENCODER_FP32,
+        parakeetEncoderDataSrc: PARAKEET_TDT_ENCODER_DATA_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. Speak into your microphone (Ctrl+C to stop):\n");
+const ffmpeg = spawn("ffmpeg", [
+    ...getAudioInputArgs(),
+    "-ar",
+    "16000",
+    "-ac",
+    "1",
+    "-sample_fmt",
+    "s16",
+    "-f",
+    "s16le",
+    "pipe:1",
+], { stdio: ["ignore", "pipe", "ignore"] });
+const CHUNK_SIZE = 96000; // ~3s of 16kHz 16-bit mono
+let buffer = Buffer.alloc(0);
+let processing = false;
+ffmpeg.stdout.on("data", (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    if (buffer.length >= CHUNK_SIZE && !processing) {
+        const audioChunk = buffer.subarray(0, CHUNK_SIZE);
+        buffer = buffer.subarray(CHUNK_SIZE);
+        processing = true;
+        void (async () => {
+            try {
+                for await (const text of transcribeStream({ modelId, audioChunk })) {
+                    if (text.trim() && !text.includes("[No speech detected]")) {
+                        process.stdout.write(text);
+                    }
+                }
+            }
+            catch (err) {
+                console.error("Transcription error:", err instanceof Error ? err.message : err);
+            }
+            finally {
+                processing = false;
+            }
+        })();
+    }
+});
+async function cleanup() {
+    console.log("\n\nStopping...");
+    ffmpeg.kill();
+    await unloadModel({ modelId });
+    console.log("Done.");
+}
+process.on("SIGINT", () => void cleanup());
+process.on("SIGTERM", () => void cleanup());

package/dist/examples/transcription/parakeet-sortformer.d.ts

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