@qvac/sdk 0.7.1 → 0.8.0

package/dist/client/rpc/profiling/profiler.js

@@ -0,0 +1,139 @@
+import { nowMs, record, recordPhase, recordServerBreakdownPhases, recordDelegationBreakdownPhases, } from "../../../profiling/index.js";
+import { getGlobalSingleton } from "../../../utils/global-singleton.js";
+const CONNECTION_TRACKING_STATE_KEY = Symbol.for("@qvac/sdk:rpc-connection-tracking-state");
+function getConnectionTrackingState() {
+    return getGlobalSingleton(CONNECTION_TRACKING_STATE_KEY, () => {
+        return {
+            connectionTimeRecorded: false,
+            pendingConnectionTimeMs: undefined,
+        };
+    });
+}
+function recordRequestPhases(base, timings) {
+    recordPhase(base, "request.zodValidation", timings.requestZodValidationMs);
+    recordPhase(base, "request.stringify", timings.requestStringifyMs);
+    if (timings.requestZodValidationMs !== undefined &&
+        timings.requestStringifyMs !== undefined) {
+        recordPhase(base, "request.totalSerialization", timings.requestZodValidationMs + timings.requestStringifyMs);
+    }
+}
+function createBaseTimings(profileId, requestType) {
+    return { profileId, requestType, requestStart: nowMs() };
+}
+export function createClientTimings(profileId, requestType) {
+    return createBaseTimings(profileId, requestType);
+}
+export function createClientStreamTimings(profileId, requestType) {
+    return { ...createBaseTimings(profileId, requestType), chunkCount: 0 };
+}
+export function cacheConnectionTime(durationMs) {
+    const state = getConnectionTrackingState();
+    if (state.connectionTimeRecorded)
+        return;
+    if (state.pendingConnectionTimeMs !== undefined)
+        return;
+    state.pendingConnectionTimeMs = durationMs;
+}
+export function flushConnectionTime() {
+    const state = getConnectionTrackingState();
+    if (state.connectionTimeRecorded)
+        return;
+    if (state.pendingConnectionTimeMs === undefined)
+        return;
+    const durationMs = state.pendingConnectionTimeMs;
+    state.pendingConnectionTimeMs = undefined;
+    state.connectionTimeRecorded = true;
+    record({
+        ts: nowMs(),
+        op: "rpc",
+        kind: "rpc",
+        phase: "connection",
+        ms: durationMs,
+    });
+}
+export function recordClientEvents(timings, serverMeta) {
+    const now = nowMs();
+    const totalClientTime = now - timings.requestStart;
+    const base = {
+        ts: now,
+        op: timings.requestType,
+        kind: "rpc",
+        profileId: timings.profileId,
+    };
+    recordRequestPhases(base, timings);
+    // For unary requests, this measures send → full response received
+    if (timings.sendStart !== undefined &&
+        timings.firstResponseAt !== undefined) {
+        recordPhase(base, "serverWait", timings.firstResponseAt - timings.sendStart);
+    }
+    recordPhase(base, "response.jsonParse", timings.responseJsonParseMs);
+    recordPhase(base, "response.zodValidation", timings.responseZodValidationMs);
+    if (timings.responseJsonParseMs !== undefined &&
+        timings.responseZodValidationMs !== undefined) {
+        recordPhase(base, "response.totalParsing", timings.responseJsonParseMs + timings.responseZodValidationMs);
+    }
+    recordPhase(base, "totalClientTime", totalClientTime);
+    if (serverMeta?.server) {
+        recordServerBreakdownPhases(base, serverMeta.server, "server");
+        if (serverMeta.server.totalServerMs !== undefined) {
+            recordPhase(base, "clientOverhead", Math.max(0, totalClientTime - serverMeta.server.totalServerMs));
+        }
+    }
+    if (serverMeta?.delegation) {
+        recordDelegationBreakdownPhases(base, serverMeta.delegation);
+    }
+    if (serverMeta?.operation) {
+        recordOperationEvent(serverMeta.operation);
+    }
+}
+function recordOperationEvent(op) {
+    const event = {
+        ts: nowMs(),
+        op: op.op,
+        kind: op.kind,
+        ms: op.ms,
+    };
+    if (op.profileId !== undefined)
+        event.profileId = op.profileId;
+    if (op.gauges !== undefined)
+        event.gauges = op.gauges;
+    if (op.tags !== undefined)
+        event.tags = op.tags;
+    if (op.count !== undefined)
+        event.count = op.count;
+    record(event);
+}
+export function recordClientStreamEvents(timings, serverMeta) {
+    const now = nowMs();
+    const totalClientTime = now - timings.requestStart;
+    const base = {
+        ts: now,
+        op: timings.requestType,
+        kind: "rpc",
+        profileId: timings.profileId,
+    };
+    recordRequestPhases(base, timings);
+    if (timings.sendStart !== undefined && timings.firstChunkAt !== undefined) {
+        recordPhase(base, "ttfb", timings.firstChunkAt - timings.sendStart);
+    }
+    if (timings.firstChunkAt !== undefined && timings.lastChunkAt !== undefined) {
+        recordPhase(base, "streamDuration", timings.lastChunkAt - timings.firstChunkAt);
+    }
+    recordPhase(base, "totalClientTime", totalClientTime, {
+        count: timings.chunkCount,
+    });
+    if (serverMeta?.server) {
+        recordServerBreakdownPhases(base, serverMeta.server, "server");
+    }
+    if (serverMeta?.delegation) {
+        recordDelegationBreakdownPhases(base, serverMeta.delegation);
+    }
+    if (serverMeta?.operation) {
+        recordOperationEvent(serverMeta.operation);
+    }
+}
+export function resetConnectionTracking() {
+    const state = getConnectionTrackingState();
+    state.connectionTimeRecorded = false;
+    state.pendingConnectionTimeMs = undefined;
+}

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

@@ -1,6 +1,6 @@
 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 send<T extends Request>(request: T, options?: RPCOptions, rpc?: RPC): Promise<Response>;
+export declare function stream<T extends Request>(request: T, options?: RPCOptions, rpc?: RPC): AsyncGenerator<Response>;
 export declare function close(): Promise<void>;
 //# sourceMappingURL=rpc-client.d.ts.map

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/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/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/transcription/parakeet-ctc-filesystem.d.ts

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