@qvac/sdk 0.14.1 → 0.15.0

package/dist/server/bare/plugins/bci-whispercpp-transcription/plugin.js

@@ -1,11 +1,11 @@
-import bciAddonLogging from "@qvac/bci-whispercpp/addonLogging.js";
-import BCIWhispercpp, {} from "@qvac/bci-whispercpp";
-import { definePlugin, defineHandler, defineDuplexHandler, bciTranscribeRequestSchema, bciTranscribeResponseSchema, bciTranscribeStreamRequestSchema, bciTranscribeStreamResponseSchema, ModelType, bciConfigSchema, ADDON_BCI, } from "../../../../schemas/index.js";
-import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
-import { bciTranscribe, bciTranscribeStream, } from "../../ops/bci-transcribe.js";
-import { attachModelExecutionMs } from "../../../../profiling/model-execution.js";
-import { buildBciWhispercppArgs } from "./args.js";
-import { resolveBciConfig } from "./resolve-config.js";
+import bciAddonLogging from '@qvac/bci-whispercpp/addonLogging.js';
+import BCIWhispercpp, {} from '@qvac/bci-whispercpp';
+import { definePlugin, defineHandler, defineDuplexHandler, bciTranscribeRequestSchema, bciTranscribeResponseSchema, bciTranscribeStreamRequestSchema, bciTranscribeStreamResponseSchema, ModelType, bciConfigSchema, ADDON_BCI } from '../../../../schemas/index.js';
+import { createStreamLogger, registerAddonLogger } from '../../../../logging/index.js';
+import { bciTranscribe, bciTranscribeStream } from '../../ops/bci-transcribe.js';
+import { attachModelExecutionMs } from '../../../../profiling/model-execution.js';
+import { buildBciWhispercppArgs } from './args.js';
+import { resolveBciConfig } from './resolve-config.js';
 function createBciModel(modelId, modelPath, bciConfig, embedderPath) {
     const logger = createStreamLogger(modelId, ModelType.bciWhispercppTranscription);
     registerAddonLogger(modelId, ModelType.bciWhispercppTranscription, logger);
@@ -15,13 +15,13 @@ function createBciModel(modelId, modelPath, bciConfig, embedderPath) {
 }
 export const bciPlugin = definePlugin({
     modelType: ModelType.bciWhispercppTranscription,
-    displayName: "BCI (whisper.cpp)",
+    displayName: 'BCI (whisper.cpp)',
     addonPackage: ADDON_BCI,
     loadConfigSchema: bciConfigSchema,
     resolveConfig: resolveBciConfig,
     createModel(params) {
         const bciConfig = (params.modelConfig ?? {});
-        const { model } = createBciModel(params.modelId, params.modelPath, bciConfig, params.artifacts?.["embedderPath"] ?? "");
+        const { model } = createBciModel(params.modelId, params.modelPath, bciConfig, params.artifacts?.['embedderPath'] ?? '');
         return { model };
     },
     handlers: {
@@ -31,45 +31,45 @@ export const bciPlugin = definePlugin({
             streaming: true,
             // The BCI addon exposes a model-wide hard cancel — the running
             // neural-signal job is interrupted on `cancel()`.
-            cancel: { scope: "model", hard: true },
+            cancel: { scope: 'model', hard: true },
             handler: async function* (request) {
                 const metadata = request.metadata === true;
                 const stream = metadata
                     ? bciTranscribe({
                         modelId: request.modelId,
                         neuralData: request.neuralData,
-                        metadata: true,
+                        metadata: true
                     }, request.requestId)
                     : bciTranscribe({
                         modelId: request.modelId,
-                        neuralData: request.neuralData,
+                        neuralData: request.neuralData
                     }, request.requestId);
                 try {
                     let result = await stream.next();
                     while (!result.done) {
                         yield metadata
                             ? {
-                                type: "bciTranscribe",
-                                segment: result.value,
+                                type: 'bciTranscribe',
+                                segment: result.value
                             }
                             : {
-                                type: "bciTranscribe",
-                                text: result.value,
+                                type: 'bciTranscribe',
+                                text: result.value
                             };
                         result = await stream.next();
                     }
                     const { modelExecutionMs, stats } = result.value;
                     yield attachModelExecutionMs({
-                        type: "bciTranscribe",
-                        text: "",
+                        type: 'bciTranscribe',
+                        text: '',
                         done: true,
-                        ...(stats && { stats }),
+                        ...(stats && { stats })
                     }, modelExecutionMs);
                 }
                 finally {
                     await stream.return?.(undefined);
                 }
-            },
+            }
         }),
         bciTranscribeStream: defineDuplexHandler({
             requestSchema: bciTranscribeStreamRequestSchema,
@@ -79,7 +79,7 @@ export const bciPlugin = definePlugin({
             // Same model-wide hard cancel surface as `bciTranscribe` — the BCI
             // addon's `cancel()` tears down the active stream and interrupts the
             // running window job.
-            cancel: { scope: "model", hard: true },
+            cancel: { scope: 'model', hard: true },
             handler: async function* (request, inputStream) {
                 const metadata = request.metadata === true;
                 const iterator = metadata
@@ -88,24 +88,24 @@ export const bciPlugin = definePlugin({
                 for await (const value of iterator) {
                     yield metadata
                         ? {
-                            type: "bciTranscribeStream",
-                            segment: value,
+                            type: 'bciTranscribeStream',
+                            segment: value
                         }
                         : {
-                            type: "bciTranscribeStream",
-                            text: value,
+                            type: 'bciTranscribeStream',
+                            text: value
                         };
                 }
                 yield {
-                    type: "bciTranscribeStream",
-                    text: "",
-                    done: true,
+                    type: 'bciTranscribeStream',
+                    text: '',
+                    done: true
                 };
-            },
-        }),
+            }
+        })
     },
     logging: {
         module: bciAddonLogging,
-        namespace: ModelType.bciWhispercppTranscription,
-    },
+        namespace: ModelType.bciWhispercppTranscription
+    }
 });

package/dist/server/bare/plugins/bci-whispercpp-transcription/resolve-config.d.ts

@@ -1,4 +1,4 @@
-import type { BciConfig, ResolveContext } from "../../../../schemas/index";
+import type { BciConfig, ResolveContext } from '../../../../schemas/index';
 export declare function resolveBciConfig(cfg: BciConfig, ctx: ResolveContext): Promise<{
     config: {
         whisperConfig?: {

package/dist/server/bare/plugins/bci-whispercpp-transcription/resolve-config.js

@@ -6,6 +6,6 @@ export async function resolveBciConfig(cfg, ctx) {
     const embedderPath = await ctx.resolveModelPath(embedderModelSrc);
     return {
         config: bciConfig,
-        artifacts: { embedderPath },
+        artifacts: { embedderPath }
     };
 }

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

@@ -1,4 +1,4 @@
-import { type ClassifyRequest, type ClassificationResult } from "../../../../../schemas/index";
+import { type ClassifyRequest, type ClassificationResult } from '../../../../../schemas/index';
 export declare function classify(params: ClassifyRequest): Promise<{
     results: ClassificationResult[];
     modelExecutionMs: number;

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

@@ -1,19 +1,19 @@
-import { getModel } from "../../../registry/model-registry.js";
-import { classifyRequestSchema } from "../../../../../schemas/index.js";
-import { nowMs } from "../../../../../profiling/index.js";
+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" &&
+    return (typeof model === 'object' &&
         model !== null &&
-        "classify" in model &&
-        typeof model.classify === "function");
+        '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()");
+        throw new Error('Loaded model does not support classify()');
     }
-    const imageBytes = Buffer.from(image, "base64");
+    const imageBytes = Buffer.from(image, 'base64');
     const opts = {};
     if (topK !== undefined)
         opts.topK = topK;

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

@@ -1,4 +1,4 @@
-import { type CreateModelParams, type PluginModelResult } from "../../../../schemas/index";
+import { type CreateModelParams, type PluginModelResult } from '../../../../schemas/index';
 export declare const classificationPlugin: {
     modelType: "ggml-classification";
     displayName: string;

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

@@ -1,10 +1,10 @@
-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";
+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)",
+    displayName: 'Image Classification (GGML)',
     addonPackage: ADDON_CLASSIFICATION,
     loadConfigSchema: classificationConfigSchema,
     skipPrimaryModelPathValidation: true,
@@ -16,7 +16,7 @@ export const classificationPlugin = definePlugin({
         const inner = new ImageClassifier({
             ...(resolvedModelPath ? { modelPath: resolvedModelPath } : {}),
             logger,
-            nativeLogger: config.nativeLogger ?? false,
+            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
@@ -26,9 +26,9 @@ export const classificationPlugin = definePlugin({
             load: () => inner.load(),
             classify: (image, opts = {}) => inner.classify(image, {
                 ...(defaultTopK !== undefined && { topK: defaultTopK }),
-                ...opts,
+                ...opts
             }),
-            unload: () => inner.unload(),
+            unload: () => inner.unload()
         };
         return { model };
     },
@@ -40,16 +40,16 @@ export const classificationPlugin = definePlugin({
             // 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" },
+            cancel: { scope: 'none' },
             handler: async function* (request) {
                 const { results, modelExecutionMs } = await classify(request);
                 yield {
-                    type: "classify",
+                    type: 'classify',
                     results,
                     done: true,
-                    modelExecutionMs,
+                    modelExecutionMs
                 };
-            },
-        }),
-    },
+            }
+        })
+    }
 });

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

@@ -1,4 +1,4 @@
-import { type OCRParams, type OCRTextBlock, type OCRStats } from "../../../../../schemas/index";
+import { type OCRParams, type OCRTextBlock, type OCRStats } from '../../../../../schemas/index';
 export declare function ocr(params: OCRParams): AsyncGenerator<{
     blocks: OCRTextBlock[];
 }, {

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

@@ -1,33 +1,30 @@
-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";
+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]);
     return [Math.min(...xs), Math.min(...ys), Math.max(...xs), Math.max(...ys)];
 }
 function normalizeBlock(block) {
-    if (block &&
-        typeof block === "object" &&
-        !Array.isArray(block) &&
-        "text" in block) {
+    if (block && typeof block === 'object' && !Array.isArray(block) && 'text' in block) {
         const obj = block;
         return {
-            text: obj.text || "",
+            text: obj.text || '',
             ...(obj.bbox && { bbox: obj.bbox }),
-            ...(obj.confidence !== undefined && { confidence: obj.confidence }),
+            ...(obj.confidence !== undefined && { confidence: obj.confidence })
         };
     }
     // Addon format: [polygon, text, confidence] where polygon is [[x1,y1], [x2,y2], [x3,y3], [x4,y4]]
     if (Array.isArray(block) && block.length >= 2) {
         const blockArr = block;
         const [polygonOrBbox, text, confidence] = blockArr;
-        const textStr = typeof text === "string" ? text : "";
+        const textStr = typeof text === 'string' ? text : '';
         if (Array.isArray(polygonOrBbox) &&
             polygonOrBbox.length === 4 &&
             Array.isArray(polygonOrBbox[0]) &&
@@ -35,16 +32,16 @@ function normalizeBlock(block) {
             return {
                 text: textStr,
                 bbox: polygonToBbox(polygonOrBbox),
-                ...(confidence !== undefined && { confidence: Number(confidence) }),
+                ...(confidence !== undefined && { confidence: Number(confidence) })
             };
         }
         if (Array.isArray(polygonOrBbox) &&
             polygonOrBbox.length === 4 &&
-            typeof polygonOrBbox[0] === "number") {
+            typeof polygonOrBbox[0] === 'number') {
             return {
                 text: textStr,
                 bbox: polygonOrBbox,
-                ...(confidence !== undefined && { confidence: Number(confidence) }),
+                ...(confidence !== undefined && { confidence: Number(confidence) })
             };
         }
     }
@@ -55,16 +52,16 @@ export async function* ocr(params) {
     let imagePath;
     let cleanupPath = null;
     switch (params.image.type) {
-        case "base64": {
-            const tempDir = getCacheDir("tmp");
+        case 'base64': {
+            const tempDir = getCacheDir('tmp');
             const suffix = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
             const tempPath = path.join(tempDir, `ocr-${suffix}.png`);
-            fs.writeFileSync(tempPath, Buffer.from(params.image.value, "base64"));
+            fs.writeFileSync(tempPath, Buffer.from(params.image.value, 'base64'));
             imagePath = tempPath;
             cleanupPath = tempPath;
             break;
         }
-        case "filePath": {
+        case 'filePath': {
             imagePath = params.image.value;
             try {
                 fs.accessSync(imagePath);
@@ -81,7 +78,7 @@ export async function* ocr(params) {
         const modelStart = nowMs();
         const response = (await model.run({
             path: imagePath,
-            ...(params.options && { options: params.options }),
+            ...(params.options && { options: params.options })
         }));
         const rawData = [];
         await response
@@ -99,9 +96,13 @@ export async function* ocr(params) {
             yield { blocks };
         }
         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 }),
+            ...(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);
     }

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

@@ -1,4 +1,4 @@
-import { type CreateModelParams, type PluginModelResult, type OCRConfig, type ResolveContext, type ResolveResult } from "../../../../schemas/index";
+import { type CreateModelParams, type PluginModelResult, type OCRConfig, type ResolveContext, type ResolveResult } from '../../../../schemas/index';
 export declare const ocrPlugin: {
     modelType: "ggml-ocr";
     displayName: string;

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

@@ -1,19 +1,19 @@
-import { definePlugin, defineHandler, ocrStreamRequestSchema, ocrStreamResponseSchema, ModelType, ocrConfigSchema, ADDON_OCR, } from "../../../../schemas/index.js";
-import { ModelLoadFailedError } from "../../../../utils/errors-server.js";
-import { hyperdriveUrlSchema } from "../../../../schemas/load-model.js";
-import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
-import ocrAddonLogging from "@qvac/ocr-ggml/addonLogging.js";
-import { OcrGgml } from "@qvac/ocr-ggml";
-import { ocr } from "./ops/ocr-stream.js";
-import { attachModelExecutionMs } from "../../../../profiling/model-execution.js";
-import { OCR_CRAFT } from "../../../../models/registry/index.js";
-const OCR_DETECTOR_FILENAME = "craft_mlt_25k.gguf";
+import { definePlugin, defineHandler, ocrStreamRequestSchema, ocrStreamResponseSchema, ModelType, ocrConfigSchema, ADDON_OCR } from '../../../../schemas/index.js';
+import { ModelLoadFailedError } from '../../../../utils/errors-server.js';
+import { hyperdriveUrlSchema } from '../../../../schemas/load-model.js';
+import { createStreamLogger, registerAddonLogger } from '../../../../logging/index.js';
+import ocrAddonLogging from '@qvac/ocr-ggml/addonLogging.js';
+import { OcrGgml } from '@qvac/ocr-ggml';
+import { ocr } from './ops/ocr-stream.js';
+import { attachModelExecutionMs } from '../../../../profiling/model-execution.js';
+import { OCR_CRAFT } from '../../../../models/registry/index.js';
+const OCR_DETECTOR_FILENAME = 'craft_mlt_25k.gguf';
 function deriveDetectorSource(modelSrc) {
-    if (modelSrc.startsWith("pear://")) {
+    if (modelSrc.startsWith('pear://')) {
         const { key } = hyperdriveUrlSchema.parse(modelSrc);
         return `pear://${key}/${OCR_DETECTOR_FILENAME}`;
     }
-    if (modelSrc.startsWith("registry://")) {
+    if (modelSrc.startsWith('registry://')) {
         return OCR_CRAFT.src;
     }
     return undefined;
@@ -24,64 +24,64 @@ function createOCRModel(modelId, detectorPath, recognizerPath, ocrConfig) {
     const params = {
         pathDetector: detectorPath,
         pathRecognizer: recognizerPath,
-        langList: ocrConfig.langList || ["en"],
+        langList: ocrConfig.langList || ['en'],
         ...(ocrConfig.pipelineType !== undefined && {
-            pipelineType: ocrConfig.pipelineType,
+            pipelineType: ocrConfig.pipelineType
         }),
         ...(ocrConfig.magRatio !== undefined && { magRatio: ocrConfig.magRatio }),
         ...(ocrConfig.canvasSize !== undefined && {
-            canvasSize: ocrConfig.canvasSize,
+            canvasSize: ocrConfig.canvasSize
         }),
         ...(ocrConfig.defaultRotationAngles !== undefined && {
-            defaultRotationAngles: ocrConfig.defaultRotationAngles,
+            defaultRotationAngles: ocrConfig.defaultRotationAngles
         }),
         ...(ocrConfig.contrastRetry !== undefined && {
-            contrastRetry: ocrConfig.contrastRetry,
+            contrastRetry: ocrConfig.contrastRetry
         }),
         ...(ocrConfig.lowConfidenceThreshold !== undefined && {
-            lowConfidenceThreshold: ocrConfig.lowConfidenceThreshold,
+            lowConfidenceThreshold: ocrConfig.lowConfidenceThreshold
         }),
         ...(ocrConfig.recognizerBatchSize !== undefined && {
-            recognizerBatchSize: ocrConfig.recognizerBatchSize,
+            recognizerBatchSize: ocrConfig.recognizerBatchSize
         }),
         ...(ocrConfig.nThreads !== undefined && { nThreads: ocrConfig.nThreads }),
         ...(ocrConfig.backendDevice !== undefined && {
-            backendDevice: ocrConfig.backendDevice,
+            backendDevice: ocrConfig.backendDevice
         }),
         ...(ocrConfig.gpuDevice !== undefined && {
-            gpuDevice: ocrConfig.gpuDevice,
-        }),
+            gpuDevice: ocrConfig.gpuDevice
+        })
     };
     const args = {
         logger,
         params,
-        opts: { stats: true },
+        opts: { stats: true }
     };
     const model = new OcrGgml(args);
     return model;
 }
 export const ocrPlugin = definePlugin({
     modelType: ModelType.ggmlOcr,
-    displayName: "OCR (GGML)",
+    displayName: 'OCR (GGML)',
     addonPackage: ADDON_OCR,
     loadConfigSchema: ocrConfigSchema,
     async resolveConfig(cfg, ctx) {
         const { detectorModelSrc, ...ocrConfig } = cfg;
         const detectorSrc = detectorModelSrc ?? deriveDetectorSource(ctx.modelSrc);
         if (!detectorSrc) {
-            throw new ModelLoadFailedError("Detector model required for OCR. Use a hyperdrive source or provide detectorModelSrc");
+            throw new ModelLoadFailedError('Detector model required for OCR. Use a hyperdrive source or provide detectorModelSrc');
         }
         const detectorModelPath = await ctx.resolveModelPath(detectorSrc);
         return {
             config: ocrConfig,
-            artifacts: { detectorModelPath },
+            artifacts: { detectorModelPath }
         };
     },
     createModel(params) {
         const ocrConfig = (params.modelConfig ?? {});
-        const detectorModelPath = params.artifacts?.["detectorModelPath"];
+        const detectorModelPath = params.artifacts?.['detectorModelPath'];
         if (!detectorModelPath) {
-            throw new ModelLoadFailedError("Detector model path missing. Ensure detectorModelSrc is provided in modelConfig.");
+            throw new ModelLoadFailedError('Detector model path missing. Ensure detectorModelSrc is provided in modelConfig.');
         }
         const model = createOCRModel(params.modelId, detectorModelPath, params.modelPath, // recognizerPath
         ocrConfig);
@@ -94,38 +94,38 @@ export const ocrPlugin = definePlugin({
             streaming: true,
             // GGML OCR does not expose a cancel surface — SDK falls back
             // to soft-cancel.
-            cancel: { scope: "none" },
+            cancel: { scope: 'none' },
             handler: async function* (request) {
                 const stream = ocr({
                     modelId: request.modelId,
                     image: request.image,
-                    options: request.options,
+                    options: request.options
                 });
                 try {
                     let result = await stream.next();
                     while (!result.done) {
                         yield {
-                            type: "ocrStream",
-                            blocks: result.value.blocks,
+                            type: 'ocrStream',
+                            blocks: result.value.blocks
                         };
                         result = await stream.next();
                     }
                     const { modelExecutionMs, stats } = result.value;
                     yield attachModelExecutionMs({
-                        type: "ocrStream",
+                        type: 'ocrStream',
                         blocks: [],
                         done: true,
-                        ...(stats && { stats }),
+                        ...(stats && { stats })
                     }, modelExecutionMs);
                 }
                 finally {
                     await stream.return?.(undefined);
                 }
-            },
-        }),
+            }
+        })
     },
     logging: {
         module: ocrAddonLogging,
-        namespace: ModelType.ggmlOcr,
-    },
+        namespace: ModelType.ggmlOcr
+    }
 });

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

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

@@ -1,5 +1,5 @@
-import { getModel } from "../../../registry/model-registry.js";
-import { vlaHparamsSchema, } from "../../../../../schemas/index.js";
+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
@@ -7,6 +7,6 @@ export function vlaGetHparams(request) {
     const parsed = vlaHparamsSchema.parse(model.hparams);
     return Promise.resolve({
         hparams: parsed,
-        backendName: model.backendName ?? null,
+        backendName: model.backendName ?? null
     });
 }

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

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