@qvac/sdk 0.10.2 → 0.12.0

package/dist/server/bare/plugins/ggml-classification/ops/classify.js

@@ -0,0 +1,30 @@
+import { getModel } from "../../../registry/model-registry.js";
+import { classifyRequestSchema } from "../../../../../schemas/index.js";
+import { nowMs } from "../../../../../profiling/index.js";
+function hasClassify(model) {
+    return (typeof model === "object" &&
+        model !== null &&
+        "classify" in model &&
+        typeof model.classify === "function");
+}
+export async function classify(params) {
+    const { modelId, image, topK, width, height, channels } = classifyRequestSchema.parse(params);
+    const model = getModel(modelId);
+    if (!hasClassify(model)) {
+        throw new Error("Loaded model does not support classify()");
+    }
+    const imageBytes = Buffer.from(image, "base64");
+    const opts = {};
+    if (topK !== undefined)
+        opts.topK = topK;
+    if (width !== undefined)
+        opts.width = width;
+    if (height !== undefined)
+        opts.height = height;
+    if (channels !== undefined)
+        opts.channels = channels;
+    const modelStart = nowMs();
+    const results = await model.classify(imageBytes, opts);
+    const modelExecutionMs = nowMs() - modelStart;
+    return { results, modelExecutionMs };
+}

package/dist/server/bare/plugins/ggml-classification/plugin.d.ts

@@ -0,0 +1,32 @@
+import { type CreateModelParams, type PluginModelResult } from "../../../../schemas/index";
+export declare const classificationPlugin: {
+    modelType: "ggml-classification";
+    displayName: string;
+    addonPackage: "@qvac/classification-ggml";
+    loadConfigSchema: import("zod").ZodObject<{
+        modelPath: import("zod").ZodOptional<import("zod").ZodString>;
+        topK: import("zod").ZodOptional<import("zod").ZodNumber>;
+        nativeLogger: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod/v4/core").$strip>;
+    skipPrimaryModelPathValidation: true;
+    createModel(params: CreateModelParams): PluginModelResult;
+    handlers: {
+        classify: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
+            modelId: import("zod").ZodString;
+            image: import("zod").ZodString;
+            topK: import("zod").ZodOptional<import("zod").ZodNumber>;
+            width: import("zod").ZodOptional<import("zod").ZodNumber>;
+            height: import("zod").ZodOptional<import("zod").ZodNumber>;
+            channels: import("zod").ZodOptional<import("zod").ZodLiteral<3>>;
+            type: import("zod").ZodLiteral<"classify">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"classify">;
+            results: import("zod").ZodArray<import("zod").ZodObject<{
+                label: import("zod").ZodString;
+                confidence: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
+            done: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>>;
+    };
+};
+//# sourceMappingURL=plugin.d.ts.map

package/dist/server/bare/plugins/ggml-classification/plugin.js

@@ -0,0 +1,55 @@
+import ImageClassifier from "@qvac/classification-ggml";
+import { definePlugin, defineHandler, classifyRequestSchema, classifyResponseSchema, ModelType, classificationConfigSchema, ADDON_CLASSIFICATION, } from "../../../../schemas/index.js";
+import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
+import { classify } from "./ops/classify.js";
+export const classificationPlugin = definePlugin({
+    modelType: ModelType.ggmlClassification,
+    displayName: "Image Classification (GGML)",
+    addonPackage: ADDON_CLASSIFICATION,
+    loadConfigSchema: classificationConfigSchema,
+    skipPrimaryModelPathValidation: true,
+    createModel(params) {
+        const config = (params.modelConfig ?? {});
+        const resolvedModelPath = config.modelPath ?? (params.modelPath || undefined);
+        const logger = createStreamLogger(params.modelId, ModelType.ggmlClassification);
+        registerAddonLogger(params.modelId, ModelType.ggmlClassification, logger);
+        const inner = new ImageClassifier({
+            ...(resolvedModelPath ? { modelPath: resolvedModelPath } : {}),
+            logger,
+            nativeLogger: config.nativeLogger ?? false,
+        });
+        // Apply the load-time `topK` as a default for classify() calls so the
+        // load-config field is not silently ignored. Per-request `topK` (passed
+        // in the second arg) wins via the `...opts` spread.
+        const defaultTopK = config.topK;
+        const model = {
+            load: () => inner.load(),
+            classify: (image, opts = {}) => inner.classify(image, {
+                ...(defaultTopK !== undefined && { topK: defaultTopK }),
+                ...opts,
+            }),
+            unload: () => inner.unload(),
+        };
+        return { model };
+    },
+    handlers: {
+        classify: defineHandler({
+            requestSchema: classifyRequestSchema,
+            responseSchema: classifyResponseSchema,
+            streaming: true,
+            // Classification is a single forward pass with no addon-side cancel
+            // surface — mirrors `ocr`/`tts`/`upscale`. The yield-once handler
+            // can't be interrupted partway, so we declare scope:"none".
+            cancel: { scope: "none" },
+            handler: async function* (request) {
+                const { results, modelExecutionMs } = await classify(request);
+                yield {
+                    type: "classify",
+                    results,
+                    done: true,
+                    modelExecutionMs,
+                };
+            },
+        }),
+    },
+});

package/dist/server/bare/plugins/ggml-vla/ops/vla-hparams.d.ts

@@ -0,0 +1,3 @@
+import { type VlaHparamsRequest, type VlaHparamsResponse } from "../../../../../schemas/index";
+export declare function vlaGetHparams(request: VlaHparamsRequest): Promise<VlaHparamsResponse>;
+//# sourceMappingURL=vla-hparams.d.ts.map

package/dist/server/bare/plugins/ggml-vla/ops/vla-hparams.js

@@ -0,0 +1,12 @@
+import { getModel } from "../../../registry/model-registry.js";
+import { vlaHparamsSchema, } from "../../../../../schemas/index.js";
+export function vlaGetHparams(request) {
+    const model = getModel(request.modelId);
+    // Validate the addon-reported hparams against our schema so the wire
+    // shape stays consistent even if the underlying addon changes.
+    const parsed = vlaHparamsSchema.parse(model.hparams);
+    return Promise.resolve({
+        hparams: parsed,
+        backendName: model.backendName ?? null,
+    });
+}

package/dist/server/bare/plugins/ggml-vla/ops/vla-run.d.ts

@@ -0,0 +1,3 @@
+import { type VlaRunRequest, type VlaRunResponse } from "../../../../../schemas/index";
+export declare function vlaRun(request: VlaRunRequest): Promise<VlaRunResponse>;
+//# sourceMappingURL=vla-run.d.ts.map

package/dist/server/bare/plugins/ggml-vla/ops/vla-run.js

@@ -0,0 +1,75 @@
+import { getModel } from "../../../registry/model-registry.js";
+import {} from "../../../../../schemas/index.js";
+import { decodeBase64, encodeBase64 } from "../../../../../utils/encoding.js";
+function f32FromBase64(b64) {
+    const bytes = decodeBase64(b64);
+    // ArrayBuffer view must be aligned; copy if needed.
+    if (bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) {
+        return new Float32Array(bytes.buffer);
+    }
+    const copy = new Uint8Array(bytes.byteLength);
+    copy.set(bytes);
+    return new Float32Array(copy.buffer);
+}
+function i32FromBase64(b64) {
+    const bytes = decodeBase64(b64);
+    if (bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) {
+        return new Int32Array(bytes.buffer);
+    }
+    const copy = new Uint8Array(bytes.byteLength);
+    copy.set(bytes);
+    return new Int32Array(copy.buffer);
+}
+function u8FromBase64(b64) {
+    return decodeBase64(b64);
+}
+function f32ToBase64(arr) {
+    return encodeBase64(new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength));
+}
+function pickStats(raw) {
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const r = raw;
+    const out = {};
+    if (typeof r["vision_ms"] === "number")
+        out.vision_ms = r["vision_ms"];
+    if (typeof r["smollm2_compute_ms"] === "number")
+        out.smollm2_compute_ms = r["smollm2_compute_ms"];
+    if (typeof r["smollm2_total_ms"] === "number")
+        out.smollm2_total_ms = r["smollm2_total_ms"];
+    if (typeof r["ode_ms"] === "number")
+        out.ode_ms = r["ode_ms"];
+    if (typeof r["total_ms"] === "number")
+        out.total_ms = r["total_ms"];
+    if (typeof r["backendDevice"] === "number")
+        out.backendDevice = r["backendDevice"];
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+export async function vlaRun(request) {
+    const model = getModel(request.modelId);
+    const images = request.images.map(f32FromBase64);
+    const state = f32FromBase64(request.state);
+    const tokens = i32FromBase64(request.tokens);
+    const mask = u8FromBase64(request.mask);
+    const noise = request.noise ? f32FromBase64(request.noise) : undefined;
+    const response = await model.run({
+        images,
+        imgWidth: request.imgWidth,
+        imgHeight: request.imgHeight,
+        state,
+        tokens,
+        mask,
+        ...(noise && { noise }),
+    });
+    const result = await response.await();
+    const hp = model.hparams;
+    if (!hp) {
+        throw new Error("VLA model hparams unavailable after run");
+    }
+    return {
+        actions: f32ToBase64(result.actions),
+        actionDim: hp.actionDim,
+        chunkSize: hp.chunkSize,
+        ...(pickStats(result.stats) && { stats: pickStats(result.stats) }),
+    };
+}

package/dist/server/bare/plugins/ggml-vla/plugin.d.ts

@@ -0,0 +1,54 @@
+import { type CreateModelParams, type PluginModelResult } from "../../../../schemas/index";
+export declare const vlaPlugin: {
+    modelType: "ggml-vla";
+    displayName: string;
+    addonPackage: "@qvac/vla-ggml";
+    loadConfigSchema: import("zod").ZodObject<{
+        backend: import("zod").ZodOptional<import("zod").ZodEnum<{
+            cpu: "cpu";
+            auto: "auto";
+        }>>;
+        verbosity: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>;
+    createModel(params: CreateModelParams): PluginModelResult;
+    handlers: {
+        vlaRun: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"vlaRun">;
+            modelId: import("zod").ZodString;
+            images: import("zod").ZodArray<import("zod").ZodString>;
+            imgWidth: import("zod").ZodNumber;
+            imgHeight: import("zod").ZodNumber;
+            state: import("zod").ZodString;
+            tokens: import("zod").ZodString;
+            mask: import("zod").ZodString;
+            noise: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            actions: import("zod").ZodString;
+            actionDim: import("zod").ZodNumber;
+            chunkSize: import("zod").ZodNumber;
+            stats: import("zod").ZodOptional<import("zod").ZodObject<{
+                vision_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
+                smollm2_compute_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
+                smollm2_total_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
+                ode_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
+                total_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
+                backendDevice: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>>;
+        vlaHparams: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"vlaHparams">;
+            modelId: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            hparams: import("zod").ZodObject<{
+                chunkSize: import("zod").ZodNumber;
+                actionDim: import("zod").ZodNumber;
+                maxActionDim: import("zod").ZodNumber;
+                maxStateDim: import("zod").ZodNumber;
+                tokenizerMaxLength: import("zod").ZodNumber;
+                visionImageSize: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>;
+            backendName: import("zod").ZodNullable<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    };
+};
+//# sourceMappingURL=plugin.d.ts.map

package/dist/server/bare/plugins/ggml-vla/plugin.js

@@ -0,0 +1,57 @@
+import { VlaModel } from "@qvac/vla-ggml";
+import { definePlugin, defineHandler, vlaConfigSchema, vlaRunRequestSchema, vlaRunResponseSchema, vlaHparamsRequestSchema, vlaHparamsResponseSchema, ModelType, ADDON_VLA, } from "../../../../schemas/index.js";
+import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
+import { vlaRun } from "./ops/vla-run.js";
+import { vlaGetHparams } from "./ops/vla-hparams.js";
+// The `@qvac/vla-ggml` VlaModel exposes `load({ backend })` rather than the
+// `load(force?)` signature `PluginModel` expects. Wrap it so the plugin
+// framework can call `load()` and have the configured backend flow through.
+function wrapVlaModel(inner, loadOpts) {
+    const wrapper = inner;
+    const originalLoad = wrapper.load.bind(wrapper);
+    wrapper.load = function load() {
+        return originalLoad(loadOpts);
+    };
+    return wrapper;
+}
+export const vlaPlugin = definePlugin({
+    modelType: ModelType.ggmlVla,
+    displayName: "VLA (SmolVLA ggml)",
+    addonPackage: ADDON_VLA,
+    loadConfigSchema: vlaConfigSchema,
+    createModel(params) {
+        const config = (params.modelConfig ?? {});
+        const logger = createStreamLogger(params.modelId, ModelType.ggmlVla);
+        registerAddonLogger(params.modelId, ModelType.ggmlVla, logger);
+        const inner = new VlaModel({
+            files: { model: [params.modelPath] },
+            ...(config.verbosity !== undefined && {
+                config: { verbosity: config.verbosity },
+            }),
+            logger,
+            opts: { stats: true },
+        });
+        const backend = config.backend ?? "auto";
+        const model = wrapVlaModel(inner, { backend });
+        return { model };
+    },
+    handlers: {
+        vlaRun: defineHandler({
+            requestSchema: vlaRunRequestSchema,
+            responseSchema: vlaRunResponseSchema,
+            streaming: false,
+            // The vla-ggml addon exposes a model-wide cancel(): the running ODE /
+            // SmolLM2 prefill is interrupted. Mirrors the diffusion plugin's
+            // cancel surface.
+            cancel: { scope: "model", hard: true },
+            handler: vlaRun,
+        }),
+        vlaHparams: defineHandler({
+            requestSchema: vlaHparamsRequestSchema,
+            responseSchema: vlaHparamsResponseSchema,
+            streaming: false,
+            cancel: { scope: "none" },
+            handler: vlaGetHparams,
+        }),
+    },
+});

package/dist/server/bare/plugins/index.d.ts

@@ -3,7 +3,9 @@ export { embeddingsPlugin } from "./llamacpp-embedding/plugin";
 export { whisperPlugin } from "./whispercpp-transcription/plugin";
 export { parakeetPlugin } from "./parakeet-transcription/plugin";
 export { nmtPlugin } from "./nmtcpp-translation/plugin";
-export { ttsPlugin } from "./onnx-tts/plugin";
+export { ttsPlugin } from "./tts-ggml/plugin";
 export { ocrPlugin } from "./onnx-ocr/plugin";
 export { diffusionPlugin } from "./sdcpp-generation/plugin";
+export { vlaPlugin } from "./ggml-vla/plugin";
+export { classificationPlugin } from "./ggml-classification/plugin";
 //# sourceMappingURL=index.d.ts.map

package/dist/server/bare/plugins/index.js

@@ -3,6 +3,8 @@ export { embeddingsPlugin } from "./llamacpp-embedding/plugin.js";
 export { whisperPlugin } from "./whispercpp-transcription/plugin.js";
 export { parakeetPlugin } from "./parakeet-transcription/plugin.js";
 export { nmtPlugin } from "./nmtcpp-translation/plugin.js";
-export { ttsPlugin } from "./onnx-tts/plugin.js";
+export { ttsPlugin } from "./tts-ggml/plugin.js";
 export { ocrPlugin } from "./onnx-ocr/plugin.js";
 export { diffusionPlugin } from "./sdcpp-generation/plugin.js";
+export { vlaPlugin } from "./ggml-vla/plugin.js";
+export { classificationPlugin } from "./ggml-classification/plugin.js";

package/dist/server/bare/plugins/llamacpp-completion/ops/completion-stream.d.ts

@@ -1,17 +1,26 @@
+import type { AbortSignal } from "bare-abort-controller";
 import type { CompletionParams, CompletionStats, GenerationParams, ResponseFormat, Tool, ToolCall, ToolDialect } from "../../../../../schemas/index";
-import { noteCancelRequested as noteCancelRequestedFromState } from "./kv-cache-state";
+import type { DisposableScope } from "../../../runtime/disposable-scope";
+import type { Logger } from "../../../../../logging/types";
 interface CompletionResult {
     modelExecutionMs: number;
     stats?: CompletionStats;
     toolCalls: ToolCall[];
 }
-export declare function clearCachedMessageCounts(prefix?: string): void;
-export declare const noteCancelRequested: typeof noteCancelRequestedFromState;
 export declare function completion(params: CompletionParams & {
     tools?: Tool[];
     generationParams?: GenerationParams;
     toolDialect?: ToolDialect;
     responseFormat?: ResponseFormat;
+}, opts: {
+    signal: AbortSignal;
+    scope: DisposableScope;
+    /**
+     * Request-scoped logger forwarded to `createKvCacheSession` so
+     * kv-cache lines share the request's lifecycle prefix. Falls
+     * back to the module-level server logger when omitted.
+     */
+    logger?: Logger;
 }): AsyncGenerator<{
     token: string;
 }, CompletionResult, unknown>;