@qvac/sdk 0.18.2 → 0.19.0

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

@@ -1,103 +0,0 @@
-import { type CreateModelParams, type PluginModelResult, type OCRConfig, type ResolveContext, type ResolveResult } from '../../../../schemas/index.js';
-export declare const ocrPlugin: {
-    modelType: "ggml-ocr";
-    displayName: string;
-    addonPackage: "@qvac/ocr-ggml";
-    loadConfigSchema: import("zod").ZodObject<{
-        langList: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-        pipelineType: import("zod").ZodOptional<import("zod").ZodEnum<{
-            easyocr: "easyocr";
-            doctr: "doctr";
-        }>>;
-        magRatio: import("zod").ZodOptional<import("zod").ZodNumber>;
-        canvasSize: import("zod").ZodOptional<import("zod").ZodNumber>;
-        defaultRotationAngles: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
-        contrastRetry: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        lowConfidenceThreshold: import("zod").ZodOptional<import("zod").ZodNumber>;
-        recognizerBatchSize: import("zod").ZodOptional<import("zod").ZodNumber>;
-        nThreads: import("zod").ZodOptional<import("zod").ZodNumber>;
-        backendDevice: import("zod").ZodOptional<import("zod").ZodEnum<{
-            cpu: "cpu";
-            vulkan: "vulkan";
-            metal: "metal";
-            opencl: "opencl";
-        }>>;
-        gpuDevice: import("zod").ZodOptional<import("zod").ZodNumber>;
-        detectorModelSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
-            src: import("zod").ZodString;
-            name: import("zod").ZodOptional<import("zod").ZodString>;
-            modelId: import("zod").ZodOptional<import("zod").ZodString>;
-            registryPath: import("zod").ZodOptional<import("zod").ZodString>;
-            registrySource: import("zod").ZodOptional<import("zod").ZodString>;
-            blobCoreKey: import("zod").ZodOptional<import("zod").ZodString>;
-            blobIndex: import("zod").ZodOptional<import("zod").ZodNumber>;
-            engine: import("zod").ZodOptional<import("zod").ZodString>;
-            expectedSize: import("zod").ZodOptional<import("zod").ZodNumber>;
-            sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
-            addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
-                embeddings: "embeddings";
-                diffusion: "diffusion";
-                audiogen: "audiogen";
-                tts: "tts";
-                ocr: "ocr";
-                vla: "vla";
-                "llamacpp-completion": "llamacpp-completion";
-                "whispercpp-transcription": "whispercpp-transcription";
-                "bci-whispercpp-transcription": "bci-whispercpp-transcription";
-                "llamacpp-embedding": "llamacpp-embedding";
-                "nmtcpp-translation": "nmtcpp-translation";
-                "onnx-tts": "onnx-tts";
-                "tts-ggml": "tts-ggml";
-                "parakeet-transcription": "parakeet-transcription";
-                "ggml-ocr": "ggml-ocr";
-                "sdcpp-generation": "sdcpp-generation";
-                "audiogen-ggml": "audiogen-ggml";
-                "ggml-vla": "ggml-vla";
-                "ggml-classification": "ggml-classification";
-                llm: "llm";
-                whisper: "whisper";
-                bci: "bci";
-                nmt: "nmt";
-                parakeet: "parakeet";
-                classification: "classification";
-            }>, import("zod").ZodLiteral<"vad">]>>;
-        }, import("zod/v4/core").$strip>]>>;
-    }, import("zod/v4/core").$strip>;
-    resolveConfig(cfg: OCRConfig, ctx: ResolveContext): Promise<ResolveResult<Record<string, unknown>, "detectorModelPath">>;
-    createModel(params: CreateModelParams): PluginModelResult;
-    handlers: {
-        ocrStream: import("../../../../schemas/index.js").PluginHandlerDefinition<import("zod").ZodObject<{
-            modelId: import("zod").ZodString;
-            image: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                type: import("zod").ZodLiteral<"base64">;
-                value: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-                type: import("zod").ZodLiteral<"filePath">;
-                value: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>], "type">;
-            options: import("zod").ZodOptional<import("zod").ZodObject<{
-                paragraph: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            }, import("zod/v4/core").$strip>>;
-            type: import("zod").ZodLiteral<"ocrStream">;
-        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-            type: import("zod").ZodLiteral<"ocrStream">;
-            blocks: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-                text: import("zod").ZodString;
-                bbox: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
-                confidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>>>;
-            done: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            error: import("zod").ZodOptional<import("zod").ZodString>;
-            stats: import("zod").ZodOptional<import("zod").ZodObject<{
-                detectionTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                recognitionTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                totalTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>>;
-        }, import("zod/v4/core").$strip>>;
-    };
-    logging: {
-        module: import("@qvac/ocr-ggml/addonLogging").AddonLogging;
-        namespace: "ggml-ocr";
-    };
-};
-//# sourceMappingURL=plugin.d.ts.map

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

@@ -1,112 +0,0 @@
-import { definePlugin, defineHandler, ocrStreamRequestSchema, ocrStreamResponseSchema, ModelType, ocrConfigSchema, ADDON_OCR } from '../../../../schemas/index.js';
-import { ModelLoadFailedError } from '../../../../utils/errors-server.js';
-import { createStreamLogger, registerAddonLogger } from '../../../../logging/index.js';
-import ocrAddonLogging from '@qvac/ocr-ggml/addonLogging';
-import { OcrGgml } from '@qvac/ocr-ggml';
-import { ocr } from '../../../../server/bare/plugins/ggml-ocr/ops/ocr-stream.js';
-import { attachModelExecutionMs } from '../../../../profiling/model-execution.js';
-import { resolveOcrConfig } from '../../../../server/bare/plugins/ggml-ocr/resolve-config.js';
-function createOCRModel(modelId, detectorPath, recognizerPath, ocrConfig) {
-    const logger = createStreamLogger(modelId, ModelType.ggmlOcr);
-    registerAddonLogger(modelId, ModelType.ggmlOcr, logger);
-    const params = {
-        pathDetector: detectorPath,
-        pathRecognizer: recognizerPath,
-        ...(ocrConfig.langList !== undefined
-            ? { langList: ocrConfig.langList }
-            : ocrConfig.pipelineType !== 'doctr' && { langList: ['en'] }),
-        ...(ocrConfig.pipelineType !== undefined && {
-            pipelineType: ocrConfig.pipelineType
-        }),
-        ...(ocrConfig.magRatio !== undefined && { magRatio: ocrConfig.magRatio }),
-        ...(ocrConfig.canvasSize !== undefined && {
-            canvasSize: ocrConfig.canvasSize
-        }),
-        ...(ocrConfig.defaultRotationAngles !== undefined && {
-            defaultRotationAngles: ocrConfig.defaultRotationAngles
-        }),
-        ...(ocrConfig.contrastRetry !== undefined && {
-            contrastRetry: ocrConfig.contrastRetry
-        }),
-        ...(ocrConfig.lowConfidenceThreshold !== undefined && {
-            lowConfidenceThreshold: ocrConfig.lowConfidenceThreshold
-        }),
-        ...(ocrConfig.recognizerBatchSize !== undefined && {
-            recognizerBatchSize: ocrConfig.recognizerBatchSize
-        }),
-        ...(ocrConfig.nThreads !== undefined && { nThreads: ocrConfig.nThreads }),
-        ...(ocrConfig.backendDevice !== undefined && {
-            backendDevice: ocrConfig.backendDevice
-        }),
-        ...(ocrConfig.gpuDevice !== undefined && {
-            gpuDevice: ocrConfig.gpuDevice
-        })
-    };
-    const args = {
-        logger,
-        params,
-        opts: { stats: true }
-    };
-    const model = new OcrGgml(args);
-    return model;
-}
-export const ocrPlugin = definePlugin({
-    modelType: ModelType.ggmlOcr,
-    displayName: 'OCR (GGML)',
-    addonPackage: ADDON_OCR,
-    loadConfigSchema: ocrConfigSchema,
-    async resolveConfig(cfg, ctx) {
-        return resolveOcrConfig(cfg, ctx);
-    },
-    createModel(params) {
-        const ocrConfig = (params.modelConfig ?? {});
-        const detectorModelPath = params.artifacts?.['detectorModelPath'];
-        if (!detectorModelPath) {
-            throw new ModelLoadFailedError('Detector model path missing. Ensure detectorModelSrc is provided in modelConfig.');
-        }
-        const model = createOCRModel(params.modelId, detectorModelPath, params.modelPath, // recognizerPath
-        ocrConfig);
-        return { model };
-    },
-    handlers: {
-        ocrStream: defineHandler({
-            requestSchema: ocrStreamRequestSchema,
-            responseSchema: ocrStreamResponseSchema,
-            streaming: true,
-            // GGML OCR does not expose a cancel surface — SDK falls back
-            // to soft-cancel.
-            cancel: { scope: 'none' },
-            handler: async function* (request) {
-                const stream = ocr({
-                    modelId: request.modelId,
-                    image: request.image,
-                    options: request.options
-                });
-                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: [],
-                        done: true,
-                        ...(stats && { stats })
-                    }, modelExecutionMs);
-                }
-                finally {
-                    await stream.return?.(undefined);
-                }
-            }
-        })
-    },
-    logging: {
-        module: ocrAddonLogging,
-        namespace: ModelType.ggmlOcr
-    }
-});

package/dist/server/bare/plugins/ggml-ocr/resolve-config.d.ts

@@ -1,6 +0,0 @@
-import { type OCRConfig, type ResolveContext, type ResolveResult } from '../../../../schemas/index.js';
-type OcrPipelineType = NonNullable<OCRConfig['pipelineType']>;
-export declare const DETECTOR_FILENAMES: Record<OcrPipelineType, string>;
-export declare function resolveOcrConfig(cfg: OCRConfig, ctx: ResolveContext): Promise<ResolveResult<Record<string, unknown>, 'detectorModelPath'>>;
-export {};
-//# sourceMappingURL=resolve-config.d.ts.map

package/dist/server/bare/plugins/ggml-ocr/resolve-config.js

@@ -1,73 +0,0 @@
-import {} from '../../../../schemas/index.js';
-import { ModelLoadFailedError } from '../../../../utils/errors-server.js';
-import { hyperdriveUrlSchema } from '../../../../schemas/load-model.js';
-import { OCR_CRAFT, OCR_DOCTR_1 } from '../../../../models/registry/index.js';
-// Detector weights paired with each pipeline. EasyOCR runs CRAFT
-// detection, DocTR runs DBNet detection — the addon cannot load one
-// pipeline's detector into the other.
-export const DETECTOR_FILENAMES = {
-    easyocr: 'craft_mlt_25k.gguf',
-    doctr: 'db_mobilenet_v3_large.gguf'
-};
-const DETECTOR_REGISTRY_SOURCES = {
-    easyocr: OCR_CRAFT.src,
-    doctr: OCR_DOCTR_1.src
-};
-// The addon defaults to the EasyOCR pipeline, so a DocTR recognizer
-// loaded without an explicit `pipelineType` dies deep in the EasyOCR
-// CRNN weight loader with a raw missing-tensor error (QVAC-22514).
-// Recognize the known DocTR registry artifacts by name and opt in to
-// the DocTR pipeline automatically.
-function inferPipelineType(recognizerSrc) {
-    const path = srcPathname(recognizerSrc);
-    const filename = path.split('/').pop() ?? '';
-    if (filename === 'crnn_mobilenet_v3_small.gguf' || path.includes('/gguf/doctr')) {
-        return 'doctr';
-    }
-    return undefined;
-}
-function srcPathname(src) {
-    return (src.split(/[?#]/)[0] ?? '').toLowerCase();
-}
-function srcToString(src) {
-    return typeof src === 'string' ? src : src.src;
-}
-// The registry still lists legacy `.onnx` OCR artifacts under the
-// "@qvac/ocr-onnx" engine; the ggml-ocr addon can only open GGUF, so a
-// raw "failed to open GGUF" surfaces mid-load. Fail fast with the
-// supported configurations instead (QVAC-22514).
-function assertGgufSource(src, role) {
-    if (!srcPathname(src).endsWith('.onnx'))
-        return;
-    throw new ModelLoadFailedError(`ggml-ocr only loads GGUF models, but the ${role} source points to an ONNX file: ${src}. ` +
-        'The .onnx OCR registry entries are legacy artifacts of the removed "onnx-ocr" engine. ' +
-        'Supported registry configurations: EasyOCR (default) — modelSrc: OCR_LATIN.src (detector OCR_CRAFT auto-derived); ' +
-        'DocTR — modelSrc: OCR_DOCTR.src (pipelineType and detector OCR_DOCTR_1 auto-derived).');
-}
-function deriveDetectorSource(modelSrc, pipelineType) {
-    if (modelSrc.startsWith('pear://')) {
-        const { key } = hyperdriveUrlSchema.parse(modelSrc);
-        return `pear://${key}/${DETECTOR_FILENAMES[pipelineType]}`;
-    }
-    if (modelSrc.startsWith('registry://')) {
-        return DETECTOR_REGISTRY_SOURCES[pipelineType];
-    }
-    return undefined;
-}
-export async function resolveOcrConfig(cfg, ctx) {
-    const { detectorModelSrc, ...ocrConfig } = cfg;
-    assertGgufSource(ctx.modelSrc, 'recognizer');
-    const pipelineType = ocrConfig.pipelineType ?? inferPipelineType(ctx.modelSrc) ?? 'easyocr';
-    const detectorSrc = detectorModelSrc ?? deriveDetectorSource(ctx.modelSrc, pipelineType);
-    if (!detectorSrc) {
-        throw new ModelLoadFailedError(`Detector model required for OCR (${pipelineType} pipeline expects ` +
-            `${DETECTOR_FILENAMES[pipelineType]}). Use a hyperdrive or registry ` +
-            'source, or provide detectorModelSrc');
-    }
-    assertGgufSource(srcToString(detectorSrc), 'detector');
-    const detectorModelPath = await ctx.resolveModelPath(detectorSrc);
-    return {
-        config: { ...ocrConfig, pipelineType },
-        artifacts: { detectorModelPath }
-    };
-}

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

@@ -1,3 +0,0 @@
-import { type VlaHparamsRequest, type VlaHparamsResponse } from '../../../../../schemas/index.js';
-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

@@ -1,12 +0,0 @@
-import { getModel } from '../../../../../server/bare/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

@@ -1,3 +0,0 @@
-import { type VlaRunRequest, type VlaRunResponse } from '../../../../../schemas/index.js';
-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

@@ -1,79 +0,0 @@
-import { getModel } from '../../../../../server/bare/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['prefill_compute_ms'] === 'number')
-        out.prefill_compute_ms = r['prefill_compute_ms'];
-    if (typeof r['prefill_total_ms'] === 'number')
-        out.prefill_total_ms = r['prefill_total_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/ops/vla-set-embodiment.d.ts

@@ -1,3 +0,0 @@
-import { type VlaSetEmbodimentRequest, type VlaSetEmbodimentResponse } from '../../../../../schemas/index.js';
-export declare function vlaSetEmbodiment(request: VlaSetEmbodimentRequest): Promise<VlaSetEmbodimentResponse>;
-//# sourceMappingURL=vla-set-embodiment.d.ts.map

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

@@ -1,9 +0,0 @@
-import { getModel } from '../../../../../server/bare/registry/model-registry.js';
-import { vlaHparamsSchema } from '../../../../../schemas/index.js';
-export async function vlaSetEmbodiment(request) {
-    const model = getModel(request.modelId);
-    const hparams = await model.setEmbodiment(request.embodiment);
-    // Validate the addon-reported hparams against our schema so the wire
-    // shape stays consistent even if the underlying addon changes.
-    return { hparams: vlaHparamsSchema.parse(hparams) };
-}

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

@@ -1,103 +0,0 @@
-import { type CreateModelParams, type PluginModelResult } from '../../../../schemas/index.js';
-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>;
-        embodiment: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodObject<{
-            tag: import("zod").ZodOptional<import("zod").ZodString>;
-            catId: import("zod").ZodOptional<import("zod").ZodNumber>;
-            numCameras: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>]>>;
-    }, import("zod/v4/core").$strip>;
-    createModel(params: CreateModelParams): PluginModelResult;
-    handlers: {
-        vlaRun: import("../../../../schemas/index.js").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>;
-                prefill_compute_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
-                prefill_total_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.js").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;
-                numCameras: import("zod").ZodOptional<import("zod").ZodNumber>;
-                stateInputMode: import("zod").ZodOptional<import("zod").ZodEnum<{
-                    discrete: "discrete";
-                    continuous: "continuous";
-                }>>;
-                imageInputMode: import("zod").ZodOptional<import("zod").ZodEnum<{
-                    pixels: "pixels";
-                    patches: "patches";
-                }>>;
-                imagePatchElems: import("zod").ZodOptional<import("zod").ZodNumber>;
-                selectedEmbodimentTag: import("zod").ZodOptional<import("zod").ZodString>;
-                selectedEmbodimentCatId: import("zod").ZodOptional<import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>;
-            backendName: import("zod").ZodNullable<import("zod").ZodString>;
-        }, import("zod/v4/core").$strip>>;
-        vlaSetEmbodiment: import("../../../../schemas/index.js").PluginHandlerDefinition<import("zod").ZodObject<{
-            type: import("zod").ZodLiteral<"vlaSetEmbodiment">;
-            modelId: import("zod").ZodString;
-            embodiment: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodObject<{
-                tag: import("zod").ZodOptional<import("zod").ZodString>;
-                catId: import("zod").ZodOptional<import("zod").ZodNumber>;
-                numCameras: import("zod").ZodOptional<import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>]>;
-        }, 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;
-                numCameras: import("zod").ZodOptional<import("zod").ZodNumber>;
-                stateInputMode: import("zod").ZodOptional<import("zod").ZodEnum<{
-                    discrete: "discrete";
-                    continuous: "continuous";
-                }>>;
-                imageInputMode: import("zod").ZodOptional<import("zod").ZodEnum<{
-                    pixels: "pixels";
-                    patches: "patches";
-                }>>;
-                imagePatchElems: import("zod").ZodOptional<import("zod").ZodNumber>;
-                selectedEmbodimentTag: import("zod").ZodOptional<import("zod").ZodString>;
-                selectedEmbodimentCatId: import("zod").ZodOptional<import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>;
-        }, import("zod/v4/core").$strip>>;
-    };
-};
-//# sourceMappingURL=plugin.d.ts.map

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

@@ -1,74 +0,0 @@
-import { VlaModel } from '@qvac/vla-ggml';
-import { definePlugin, defineHandler, vlaConfigSchema, vlaRunRequestSchema, vlaRunResponseSchema, vlaHparamsRequestSchema, vlaHparamsResponseSchema, vlaSetEmbodimentRequestSchema, vlaSetEmbodimentResponseSchema, 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';
-import { vlaSetEmbodiment } from './ops/vla-set-embodiment.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 / π₀.₅ / GR00T 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 addonConfig = {
-            ...(config.verbosity !== undefined && { verbosity: config.verbosity }),
-            // The zod-inferred selector widens optional props with `| undefined`,
-            // which exactOptionalPropertyTypes rejects against the addon's exact
-            // shape — the runtime value is identical, so re-assert the addon type.
-            ...(config.embodiment !== undefined && {
-                embodiment: config.embodiment
-            })
-        };
-        const inner = new VlaModel({
-            files: { model: [params.modelPath] },
-            ...(Object.keys(addonConfig).length > 0 && { config: addonConfig }),
-            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
-        }),
-        vlaSetEmbodiment: defineHandler({
-            requestSchema: vlaSetEmbodimentRequestSchema,
-            responseSchema: vlaSetEmbodimentResponseSchema,
-            streaming: false,
-            // The addon refuses to switch while an inference job is in flight
-            // (JOB_ALREADY_RUNNING), so there is nothing meaningful to cancel here.
-            cancel: { scope: 'none' },
-            handler: vlaSetEmbodiment
-        })
-    }
-});

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

@@ -1,13 +0,0 @@
-export { llmPlugin } from './llamacpp-completion/plugin.js';
-export { embeddingsPlugin } from './llamacpp-embedding/plugin.js';
-export { whisperPlugin } from './whispercpp-transcription/plugin.js';
-export { bciPlugin } from './bci-whispercpp-transcription/plugin.js';
-export { parakeetPlugin } from './parakeet-transcription/plugin.js';
-export { nmtPlugin } from './nmtcpp-translation/plugin.js';
-export { ttsPlugin } from './tts-ggml/plugin.js';
-export { ocrPlugin } from './ggml-ocr/plugin.js';
-export { diffusionPlugin } from './sdcpp-generation/plugin.js';
-export { vlaPlugin } from './ggml-vla/plugin.js';
-export { classificationPlugin } from './ggml-classification/plugin.js';
-export { audioGenPlugin } from '../../../server/bare/plugins/audiogen-ggml/plugin.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,12 +0,0 @@
-export { llmPlugin } from './llamacpp-completion/plugin.js';
-export { embeddingsPlugin } from './llamacpp-embedding/plugin.js';
-export { whisperPlugin } from './whispercpp-transcription/plugin.js';
-export { bciPlugin } from './bci-whispercpp-transcription/plugin.js';
-export { parakeetPlugin } from './parakeet-transcription/plugin.js';
-export { nmtPlugin } from './nmtcpp-translation/plugin.js';
-export { ttsPlugin } from './tts-ggml/plugin.js';
-export { ocrPlugin } from './ggml-ocr/plugin.js';
-export { diffusionPlugin } from './sdcpp-generation/plugin.js';
-export { vlaPlugin } from './ggml-vla/plugin.js';
-export { classificationPlugin } from './ggml-classification/plugin.js';
-export { audioGenPlugin } from '../../../server/bare/plugins/audiogen-ggml/plugin.js';