@qvac/sdk 0.8.2 → 0.9.0

package/dist/server/bare/plugins/llamacpp-embedding/plugin.d.ts

@@ -6,8 +6,8 @@ export declare const embeddingsPlugin: {
     loadConfigSchema: import("zod").ZodObject<{
         gpuLayers: import("zod").ZodOptional<import("zod").ZodNumber>;
         device: import("zod").ZodOptional<import("zod").ZodEnum<{
-            gpu: "gpu";
             cpu: "cpu";
+            gpu: "gpu";
         }>>;
         batchSize: import("zod").ZodOptional<import("zod").ZodNumber>;
         pooling: import("zod").ZodOptional<import("zod").ZodEnum<{
@@ -32,6 +32,7 @@ export declare const embeddingsPlugin: {
             dedicated: "dedicated";
         }>]>>;
         verbosity: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<0>, import("zod").ZodLiteral<1>, import("zod").ZodLiteral<2>, import("zod").ZodLiteral<3>]>>;
+        openclCacheDir: import("zod").ZodOptional<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>;
     createModel(params: CreateModelParams): PluginModelResult;
     handlers: {
@@ -43,6 +44,15 @@ export declare const embeddingsPlugin: {
             type: import("zod").ZodLiteral<"embed">;
             success: import("zod").ZodBoolean;
             embedding: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodArray<import("zod").ZodNumber>, import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodNumber>>]>>;
+            stats: import("zod").ZodOptional<import("zod").ZodObject<{
+                totalTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+                tokensPerSecond: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
+                backendDevice: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    cpu: "cpu";
+                    gpu: "gpu";
+                }>>;
+            }, import("zod/v4/core").$strip>>;
             error: import("zod").ZodOptional<import("zod").ZodString>;
         }, import("zod/v4/core").$strip>>;
     };

package/dist/server/bare/plugins/llamacpp-embedding/plugin.js

@@ -6,6 +6,7 @@ import { parseModelPath } from "../../../utils/index.js";
 import FilesystemDL from "@qvac/dl-filesystem";
 import { asLoader } from "../../utils/loader-adapter.js";
 import { embed } from "../../ops/embed.js";
+import { forwardModelExecution } from "../../../../profiling/model-execution.js";
 function transformEmbedConfig(embedConfig) {
     const config = {
         device: embedConfig.device,
@@ -33,6 +34,9 @@ function transformEmbedConfig(embedConfig) {
     if (typeof embedConfig.verbosity === "number") {
         config.verbosity = `${embedConfig.verbosity}`;
     }
+    if (embedConfig.openclCacheDir) {
+        config.openclCacheDir = embedConfig.openclCacheDir;
+    }
     return config;
 }
 function createEmbeddingsModel(modelId, modelPath, embedConfig) {
@@ -68,15 +72,16 @@ export const embeddingsPlugin = definePlugin({
             responseSchema: embedResponseSchema,
             streaming: false,
             handler: async function (request) {
-                const embedding = await embed({
+                const embedResult = await embed({
                     modelId: request.modelId,
                     text: request.text,
                 });
-                return {
+                return forwardModelExecution({
                     type: "embed",
                     success: true,
-                    embedding,
-                };
+                    embedding: embedResult.embedding,
+                    ...(embedResult.stats && { stats: embedResult.stats }),
+                }, embedResult);
             },
         }),
     },

package/dist/server/bare/plugins/nmtcpp-translation/plugin.d.ts

@@ -118,6 +118,7 @@ export declare const nmtPlugin: {
                 "onnx-tts": "onnx-tts";
                 "parakeet-transcription": "parakeet-transcription";
                 "onnx-ocr": "onnx-ocr";
+                "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
                 embeddings: "embeddings";
@@ -125,6 +126,7 @@ export declare const nmtPlugin: {
                 parakeet: "parakeet";
                 tts: "tts";
                 ocr: "ocr";
+                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
         dstVocabSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
@@ -146,6 +148,7 @@ export declare const nmtPlugin: {
                 "onnx-tts": "onnx-tts";
                 "parakeet-transcription": "parakeet-transcription";
                 "onnx-ocr": "onnx-ocr";
+                "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
                 embeddings: "embeddings";
@@ -153,6 +156,7 @@ export declare const nmtPlugin: {
                 parakeet: "parakeet";
                 tts: "tts";
                 ocr: "ocr";
+                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
         normalize: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -187,6 +191,7 @@ export declare const nmtPlugin: {
                     "onnx-tts": "onnx-tts";
                     "parakeet-transcription": "parakeet-transcription";
                     "onnx-ocr": "onnx-ocr";
+                    "sdcpp-generation": "sdcpp-generation";
                     llm: "llm";
                     whisper: "whisper";
                     embeddings: "embeddings";
@@ -194,6 +199,7 @@ export declare const nmtPlugin: {
                     parakeet: "parakeet";
                     tts: "tts";
                     ocr: "ocr";
+                    diffusion: "diffusion";
                 }>, import("zod").ZodLiteral<"vad">]>>;
             }, import("zod/v4/core").$strip>]>;
             srcVocabSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
@@ -215,6 +221,7 @@ export declare const nmtPlugin: {
                     "onnx-tts": "onnx-tts";
                     "parakeet-transcription": "parakeet-transcription";
                     "onnx-ocr": "onnx-ocr";
+                    "sdcpp-generation": "sdcpp-generation";
                     llm: "llm";
                     whisper: "whisper";
                     embeddings: "embeddings";
@@ -222,6 +229,7 @@ export declare const nmtPlugin: {
                     parakeet: "parakeet";
                     tts: "tts";
                     ocr: "ocr";
+                    diffusion: "diffusion";
                 }>, import("zod").ZodLiteral<"vad">]>>;
             }, import("zod/v4/core").$strip>]>>;
             dstVocabSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
@@ -243,6 +251,7 @@ export declare const nmtPlugin: {
                     "onnx-tts": "onnx-tts";
                     "parakeet-transcription": "parakeet-transcription";
                     "onnx-ocr": "onnx-ocr";
+                    "sdcpp-generation": "sdcpp-generation";
                     llm: "llm";
                     whisper: "whisper";
                     embeddings: "embeddings";
@@ -250,6 +259,7 @@ export declare const nmtPlugin: {
                     parakeet: "parakeet";
                     tts: "tts";
                     ocr: "ocr";
+                    diffusion: "diffusion";
                 }>, import("zod").ZodLiteral<"vad">]>>;
             }, import("zod/v4/core").$strip>]>>;
             normalize: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -353,8 +363,13 @@ export declare const nmtPlugin: {
             token: import("zod").ZodString;
             done: import("zod").ZodOptional<import("zod").ZodBoolean>;
             stats: import("zod").ZodOptional<import("zod").ZodObject<{
-                processedTokens: import("zod").ZodNumber;
-                processingTime: import("zod").ZodNumber;
+                totalTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
+                tokensPerSecond: import("zod").ZodOptional<import("zod").ZodNumber>;
+                timeToFirstToken: import("zod").ZodOptional<import("zod").ZodNumber>;
+                decodeTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+                encodeTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+                cacheTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
             }, import("zod/v4/core").$strip>>;
             error: import("zod").ZodOptional<import("zod").ZodString>;
         }, import("zod/v4/core").$strip>>;

package/dist/server/bare/plugins/nmtcpp-translation/plugin.js

@@ -7,6 +7,7 @@ import FilesystemDL from "@qvac/dl-filesystem";
 import { ModelLoadFailedError } from "../../../../utils/errors-server.js";
 import { asLoader } from "../../utils/loader-adapter.js";
 import { translate } from "../../ops/translate.js";
+import { attachModelExecutionMs } from "../../../../profiling/model-execution.js";
 const BERGAMOT_CJK_LANG_PAIRS = ["enja", "enko", "enzh"];
 function buildBergamotVocabSources(basePath, langPair) {
     if (BERGAMOT_CJK_LANG_PAIRS.includes(langPair)) {
@@ -45,6 +46,7 @@ function createNmtModel(modelId, modelPath, nmtConfig, srcVocabPath, dstVocabPat
         logger,
         modelName: basePath,
         diskPath: dirPath,
+        opts: { stats: true },
         params: {
             mode,
             srcLang: from,
@@ -170,27 +172,26 @@ export const nmtPlugin = definePlugin({
             streaming: true,
             handler: async function* (request) {
                 const stream = translate(request);
-                let done = false;
-                let stats;
-                while (!done) {
-                    const result = await stream.next();
-                    if (result.done) {
-                        stats = result.value;
-                        done = true;
-                    }
-                    else {
+                try {
+                    let result = await stream.next();
+                    while (!result.done) {
                         yield {
                             type: "translate",
                             token: result.value,
                         };
+                        result = await stream.next();
                     }
+                    const { modelExecutionMs, stats } = result.value;
+                    yield attachModelExecutionMs({
+                        type: "translate",
+                        token: "",
+                        done: true,
+                        ...(stats && { stats }),
+                    }, modelExecutionMs);
+                }
+                finally {
+                    await stream.return?.(undefined);
                 }
-                yield {
-                    type: "translate",
-                    token: "",
-                    done: true,
-                    ...(stats && { stats }),
-                };
             },
         }),
     },

package/dist/server/bare/plugins/onnx-ocr/ops/ocr-stream.d.ts

@@ -1,10 +1,8 @@
-import type { OCRParams, OCRTextBlock } from "../../../../../schemas/ocr";
+import { type OCRParams, type OCRTextBlock, type OCRStats } from "../../../../../schemas/index";
 export declare function ocr(params: OCRParams): AsyncGenerator<{
     blocks: OCRTextBlock[];
-    stats?: {
-        detectionTime?: number;
-        recognitionTime?: number;
-        totalTime?: number;
-    };
-}, void, void>;
+}, {
+    modelExecutionMs: number;
+    stats?: OCRStats;
+}, void>;
 //# sourceMappingURL=ocr-stream.d.ts.map

package/dist/server/bare/plugins/onnx-ocr/ops/ocr-stream.js

@@ -1,8 +1,11 @@
 import { getModel } from "../../../registry/model-registry.js";
 import fs from "bare-fs";
 import path from "bare-path";
+import {} from "../../../../../schemas/index.js";
+import { buildStreamResult, hasDefinedValues } from "../../../../../profiling/model-execution.js";
 import { getCacheDir } from "../../../../utils/index.js";
 import { ImageFileNotFoundError, InvalidImageInputError, } from "../../../../../utils/errors-server.js";
+import { nowMs } from "../../../../../profiling/index.js";
 function polygonToBbox(polygon) {
     const xs = polygon.map((p) => p[0]);
     const ys = polygon.map((p) => p[1]);
@@ -75,6 +78,7 @@ export async function* ocr(params) {
             throw new InvalidImageInputError();
     }
     try {
+        const modelStart = nowMs();
         const response = (await model.run({
             path: imagePath,
             ...(params.options && { options: params.options }),
@@ -86,6 +90,7 @@ export async function* ocr(params) {
             return [];
         })
             .await();
+        const modelExecutionMs = nowMs() - modelStart;
         const blocks = rawData
             .flat(1)
             .map(normalizeBlock)
@@ -93,9 +98,12 @@ export async function* ocr(params) {
         if (blocks.length > 0) {
             yield { blocks };
         }
-        if (response.stats) {
-            yield { blocks: [], stats: response.stats };
-        }
+        const stats = {
+            ...(response.stats?.detectionTime !== undefined && { detectionTime: response.stats.detectionTime }),
+            ...(response.stats?.recognitionTime !== undefined && { recognitionTime: response.stats.recognitionTime }),
+            ...(response.stats?.totalTime !== undefined && { totalTime: response.stats.totalTime }),
+        };
+        return buildStreamResult(modelExecutionMs, hasDefinedValues(stats) ? stats : undefined);
     }
     finally {
         if (cleanupPath) {

package/dist/server/bare/plugins/onnx-ocr/plugin.d.ts

@@ -40,6 +40,7 @@ export declare const ocrPlugin: {
                 "onnx-tts": "onnx-tts";
                 "parakeet-transcription": "parakeet-transcription";
                 "onnx-ocr": "onnx-ocr";
+                "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
                 embeddings: "embeddings";
@@ -47,6 +48,7 @@ export declare const ocrPlugin: {
                 parakeet: "parakeet";
                 tts: "tts";
                 ocr: "ocr";
+                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
     }, import("zod/v4/core").$strip>;

package/dist/server/bare/plugins/onnx-ocr/plugin.js

@@ -2,10 +2,9 @@ import { definePlugin, defineHandler, ocrStreamRequestSchema, ocrStreamResponseS
 import { ModelLoadFailedError } from "../../../../utils/errors-server.js";
 import { hyperdriveUrlSchema } from "../../../../schemas/load-model.js";
 import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
-import { parseModelPath } from "../../../utils/index.js";
-import FilesystemDL from "@qvac/dl-filesystem";
 import { ONNXOcr } from "@qvac/ocr-onnx";
 import { ocr } from "./ops/ocr-stream.js";
+import { attachModelExecutionMs } from "../../../../profiling/model-execution.js";
 import { OCR_CRAFT_DETECTOR } from "../../../../models/registry/index.js";
 const OCR_DETECTOR_FILENAME = "detector_craft.onnx";
 function deriveDetectorSource(modelSrc) {
@@ -19,8 +18,6 @@ function deriveDetectorSource(modelSrc) {
     return undefined;
 }
 function createOCRModel(modelId, detectorPath, recognizerPath, ocrConfig) {
-    const { dirPath } = parseModelPath(detectorPath);
-    const loader = new FilesystemDL({ dirPath });
     const logger = createStreamLogger(modelId, ModelType.onnxOcr);
     registerAddonLogger(modelId, ModelType.onnxOcr, logger);
     const params = {
@@ -53,14 +50,13 @@ function createOCRModel(modelId, detectorPath, recognizerPath, ocrConfig) {
         }),
     };
     const args = {
-        loader: loader,
         logger,
         params,
         opts: { stats: true },
     };
     // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
     const model = new ONNXOcr(args);
-    return { model, loader };
+    return model;
 }
 export const ocrPlugin = definePlugin({
     modelType: ModelType.onnxOcr,
@@ -85,9 +81,9 @@ export const ocrPlugin = definePlugin({
         if (!detectorModelPath) {
             throw new ModelLoadFailedError("Detector model path missing. Ensure detectorModelSrc is provided in modelConfig.");
         }
-        const { model, loader } = createOCRModel(params.modelId, detectorModelPath, params.modelPath, // recognizerPath
+        const model = createOCRModel(params.modelId, detectorModelPath, params.modelPath, // recognizerPath
         ocrConfig);
-        return { model, loader };
+        return { model, loader: null };
     },
     handlers: {
         ocrStream: defineHandler({
@@ -95,22 +91,31 @@ export const ocrPlugin = definePlugin({
             responseSchema: ocrStreamResponseSchema,
             streaming: true,
             handler: async function* (request) {
-                for await (const result of ocr({
+                const stream = ocr({
                     modelId: request.modelId,
                     image: request.image,
                     options: request.options,
-                })) {
-                    yield {
+                });
+                try {
+                    let result = await stream.next();
+                    while (!result.done) {
+                        yield {
+                            type: "ocrStream",
+                            blocks: result.value.blocks,
+                        };
+                        result = await stream.next();
+                    }
+                    const { modelExecutionMs, stats } = result.value;
+                    yield attachModelExecutionMs({
                         type: "ocrStream",
-                        blocks: result.blocks,
-                        ...(result.stats && { stats: result.stats }),
-                    };
+                        blocks: [],
+                        done: true,
+                        ...(stats && { stats }),
+                    }, modelExecutionMs);
+                }
+                finally {
+                    await stream.return?.(undefined);
                 }
-                yield {
-                    type: "ocrStream",
-                    blocks: [],
-                    done: true,
-                };
             },
         }),
     },

package/dist/server/bare/plugins/onnx-tts/ops/text-to-speech.d.ts

@@ -1,3 +1,8 @@
-import { type TtsRequest, type TtsResponse } from "../../../../../schemas/index";
-export declare function textToSpeech(params: TtsRequest): AsyncGenerator<TtsResponse>;
+import { type TtsRequest, type TtsStats } from "../../../../../schemas/index";
+export declare function textToSpeech(params: TtsRequest): AsyncGenerator<{
+    buffer: number[];
+}, {
+    modelExecutionMs: number;
+    stats?: TtsStats;
+}>;
 //# sourceMappingURL=text-to-speech.d.ts.map

package/dist/server/bare/plugins/onnx-tts/ops/text-to-speech.js

@@ -1,109 +1,34 @@
 import { getModel } from "../../../registry/model-registry.js";
 import { ttsRequestSchema } from "../../../../../schemas/index.js";
+import { nowMs } from "../../../../../profiling/index.js";
+import { buildStreamResult, hasDefinedValues } from "../../../../../profiling/model-execution.js";
 export async function* textToSpeech(params) {
     const { modelId, inputType, text, stream } = ttsRequestSchema.parse(params);
     const model = getModel(modelId);
-    const response = await model.run({ input: text, inputType });
+    const modelStart = nowMs();
+    const response = (await model.run({ input: text, inputType }));
     if (!stream) {
-        // Non-streaming mode: wait for complete response and yield once
+        // Non-streaming mode: collect all chunks and return once
         let completeBuffer = [];
-        await response
-            .onUpdate((data) => {
+        for await (const data of response.iterate()) {
             completeBuffer = completeBuffer.concat(Array.from(data.outputArray));
-        })
-            .await();
-        yield {
-            type: "textToSpeech",
-            buffer: completeBuffer,
-            done: true,
+        }
+        const modelExecutionMs = nowMs() - modelStart;
+        const stats = {
+            ...(response.stats?.audioDurationMs !== undefined && { audioDuration: response.stats.audioDurationMs }),
+            ...(response.stats?.totalSamples !== undefined && { totalSamples: response.stats.totalSamples }),
         };
+        yield { buffer: completeBuffer };
+        return buildStreamResult(modelExecutionMs, hasDefinedValues(stats) ? stats : undefined);
     }
-    else {
-        // Streaming mode: use async iterator pattern
-        const outputQueue = [];
-        let isComplete = false;
-        let streamError = null;
-        let resolveNext = null;
-        let rejectNext = null;
-        // Start the response processing
-        const responsePromise = response
-            .onUpdate((data) => {
-            if (resolveNext) {
-                // If there's a pending read, resolve it immediately
-                resolveNext({
-                    value: {
-                        type: "textToSpeech",
-                        buffer: Array.from(data.outputArray),
-                        done: false,
-                    },
-                    done: false,
-                });
-                resolveNext = null;
-                rejectNext = null;
-            }
-            else {
-                // Otherwise, queue the output
-                outputQueue.push(data);
-            }
-        })
-            .await()
-            .then(() => {
-            isComplete = true;
-            if (resolveNext) {
-                resolveNext({ value: undefined, done: true });
-                resolveNext = null;
-                rejectNext = null;
-            }
-        })
-            .catch((err) => {
-            streamError = err;
-            isComplete = true;
-            if (rejectNext) {
-                rejectNext(err);
-                resolveNext = null;
-                rejectNext = null;
-            }
-        });
-        // Create an async iterator
-        const asyncIterator = {
-            async next() {
-                if (streamError) {
-                    if (streamError instanceof Error)
-                        throw streamError;
-                    const message = typeof streamError === "string"
-                        ? streamError
-                        : JSON.stringify(streamError);
-                    throw new Error(message);
-                }
-                if (outputQueue.length > 0) {
-                    const data = outputQueue.shift();
-                    return {
-                        value: {
-                            type: "textToSpeech",
-                            buffer: Array.from(data.outputArray),
-                            done: false,
-                        },
-                        done: false,
-                    };
-                }
-                if (isComplete) {
-                    return { value: undefined, done: true };
-                }
-                // Wait for the next output
-                return new Promise((resolve, reject) => {
-                    resolveNext = resolve;
-                    rejectNext = reject;
-                });
-            },
-            [Symbol.asyncIterator]() {
-                return this;
-            },
-        };
-        // Yield outputs as they come
-        for await (const output of asyncIterator) {
-            yield output;
-        }
-        // Ensure the response is fully processed
-        await responsePromise;
+    // Streaming mode: yield chunks as they arrive
+    for await (const data of response.iterate()) {
+        yield { buffer: Array.from(data.outputArray) };
     }
+    const modelExecutionMs = nowMs() - modelStart;
+    const stats = {
+        ...(response.stats?.audioDurationMs !== undefined && { audioDuration: response.stats.audioDurationMs }),
+        ...(response.stats?.totalSamples !== undefined && { totalSamples: response.stats.totalSamples }),
+    };
+    return buildStreamResult(modelExecutionMs, hasDefinedValues(stats) ? stats : undefined);
 }