@qvac/sdk 0.11.0 → 0.12.0

package/dist/server/bare/ops/transcribe.js

@@ -162,7 +162,7 @@ export async function* transcribe(params, requestId) {
             if (ctx.signal.aborted)
                 break;
             requestLogger.debug("Streaming Transcription Update:", output);
-            const chunks = output;
+            const chunks = (Array.isArray(output) ? output : [output]);
             if (metadata) {
                 for (const chunk of chunks) {
                     if (!chunk.text)
@@ -206,6 +206,21 @@ export async function* transcribe(params, requestId) {
             await result_1;
     }
 }
+function buildRunStreamingOpts(engineType, opts) {
+    if (engineType === ModelType.parakeetTranscription) {
+        return opts?.parakeetStreamingConfig;
+    }
+    const runOpts = {};
+    if (opts?.emitVadEvents)
+        runOpts.emitVadEvents = true;
+    if (opts?.endOfTurnSilenceMs !== undefined) {
+        runOpts.endOfTurnSilenceMs = opts.endOfTurnSilenceMs;
+    }
+    if (opts?.vadRunIntervalMs !== undefined) {
+        runOpts.vadRunIntervalMs = opts.vadRunIntervalMs;
+    }
+    return runOpts;
+}
 export async function* transcribeStream(modelId, audioInputStream, prompt, metadata, opts, requestId) {
     const env_2 = { stack: [], error: void 0, hasError: false };
     try {
@@ -244,50 +259,37 @@ export async function* transcribeStream(modelId, audioInputStream, prompt, metad
         ctx.scope.defer(() => {
             ctx.signal.removeEventListener("abort", onAbort);
         });
-        const runOpts = {};
-        if (opts?.emitVadEvents)
-            runOpts.emitVadEvents = true;
-        if (opts?.endOfTurnSilenceMs !== undefined) {
-            runOpts.endOfTurnSilenceMs = opts.endOfTurnSilenceMs;
-        }
-        if (opts?.vadRunIntervalMs !== undefined) {
-            runOpts.vadRunIntervalMs = opts.vadRunIntervalMs;
-        }
+        const runOpts = buildRunStreamingOpts(engineType, opts);
         const response = await model.runStreaming(audioInputStream, runOpts);
         for await (const output of response.iterate()) {
             if (ctx.signal.aborted)
                 break;
             requestLogger.debug("Live Transcription Update:", output);
             if (!Array.isArray(output)) {
-                if (output.type === "vad") {
-                    yield {
-                        type: "vad",
-                        speaking: output.speaking,
-                        probability: output.probability,
-                    };
-                    continue;
-                }
-                if (output.type === "endOfTurn") {
-                    yield {
-                        type: "endOfTurn",
-                        silenceDurationMs: output.silenceDurationMs,
-                    };
+                if ("type" in output) {
+                    if (output.type === "vad") {
+                        yield {
+                            type: "vad",
+                            speaking: output.speaking,
+                            probability: output.probability,
+                        };
+                        continue;
+                    }
+                    if (output.type === "endOfTurn") {
+                        yield {
+                            type: "endOfTurn",
+                            source: "whisper",
+                            silenceDurationMs: output.silenceDurationMs,
+                        };
+                        continue;
+                    }
                     continue;
                 }
+                yield* emitSegment(output, metadata, silenceMarker);
                 continue;
             }
             for (const segment of output) {
-                if (!segment.text)
-                    continue;
-                if (silenceMarker && segment.text.includes(silenceMarker))
-                    continue;
-                if (metadata) {
-                    yield toTranscribeSegment(segment);
-                    continue;
-                }
-                if (segment.text.trim()) {
-                    yield segment.text;
-                }
+                yield* emitSegment(segment, metadata, silenceMarker);
             }
         }
     }
@@ -301,3 +303,26 @@ export async function* transcribeStream(modelId, audioInputStream, prompt, metad
             await result_2;
     }
 }
+function* emitSegment(segment, metadata, silenceMarker) {
+    if (!segment.text) {
+        if (segment.isEndOfTurn) {
+            yield { type: "endOfTurn", source: "parakeet" };
+        }
+        return;
+    }
+    if (silenceMarker && segment.text.includes(silenceMarker)) {
+        if (segment.isEndOfTurn) {
+            yield { type: "endOfTurn", source: "parakeet" };
+        }
+        return;
+    }
+    if (metadata) {
+        yield toTranscribeSegment(segment);
+    }
+    else if (segment.text.trim()) {
+        yield segment.text;
+    }
+    if (segment.isEndOfTurn) {
+        yield { type: "endOfTurn", source: "parakeet" };
+    }
+}

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

@@ -0,0 +1,6 @@
+import { type ClassifyRequest, type ClassificationResult } from "../../../../../schemas/index";
+export declare function classify(params: ClassifyRequest): Promise<{
+    results: ClassificationResult[];
+    modelExecutionMs: number;
+}>;
+//# sourceMappingURL=classify.d.ts.map

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.js

@@ -205,6 +205,9 @@ async function* processModelResponse(model, messagesToSend, tools, generationPar
         ...(responseWithStats.stats?.CacheTokens !== undefined && {
             cacheTokens: responseWithStats.stats.CacheTokens,
         }),
+        ...(responseWithStats.stats?.promptTokens !== undefined && {
+            promptTokens: responseWithStats.stats.promptTokens,
+        }),
         ...(responseWithStats.stats?.generatedTokens !== undefined && {
             generatedTokens: responseWithStats.stats.generatedTokens,
         }),

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

@@ -0,0 +1,29 @@
+/**
+ * Helpers for detecting and parsing the llama.cpp addon's
+ * `ContextOverflow` status error (`LlmErrors.hpp::ContextOverflow = 14`).
+ *
+ * The addon's JS-facing throw goes through `js_throw_error(env, code,
+ * msg)` (see `JsUtils.hpp::JSCATCH`) where `code` comes from
+ * `qvac_errors::StatusError::codeString()` and formats as
+ * `"[ <addonId> :: ContextOverflow ]"`. The message carries the
+ * C++-formatted detail (which may include the prompt/ctx sizes).
+ *
+ * These helpers let the plugin handler convert that addon error into a
+ * typed `ContextOverflowError` and let unit tests assert the detection
+ * + extraction logic without a real model load.
+ */
+export declare function isAddonContextOverflowError(err: unknown): boolean;
+/**
+ * Best-effort extraction of `promptTokens` / `ctxSize` from the addon
+ * error message. The C++ paths in `TextLlmContext.cpp` and
+ * `MtmdLlmContext.cpp` format both numbers into the message; the
+ * `LlamaModel::processPromptImpl` fallback path emits a bare
+ * `"<func>: context overflow\n"` with neither number. Returning
+ * `undefined` for either field is fine — `ContextOverflowError` holds
+ * them as optional and the message factory degrades gracefully.
+ */
+export declare function parseContextOverflowMessage(message: string): {
+    promptTokens?: number;
+    ctxSize?: number;
+};
+//# sourceMappingURL=context-overflow.d.ts.map

package/dist/server/bare/plugins/llamacpp-completion/ops/context-overflow.js

@@ -0,0 +1,65 @@
+/**
+ * Helpers for detecting and parsing the llama.cpp addon's
+ * `ContextOverflow` status error (`LlmErrors.hpp::ContextOverflow = 14`).
+ *
+ * The addon's JS-facing throw goes through `js_throw_error(env, code,
+ * msg)` (see `JsUtils.hpp::JSCATCH`) where `code` comes from
+ * `qvac_errors::StatusError::codeString()` and formats as
+ * `"[ <addonId> :: ContextOverflow ]"`. The message carries the
+ * C++-formatted detail (which may include the prompt/ctx sizes).
+ *
+ * These helpers let the plugin handler convert that addon error into a
+ * typed `ContextOverflowError` and let unit tests assert the detection
+ * + extraction logic without a real model load.
+ */
+export function isAddonContextOverflowError(err) {
+    if (typeof err !== "object" || err === null)
+        return false;
+    const code = err.code;
+    // Anchor to the codeString tail (`[ <addonId> :: ContextOverflow ]`)
+    // so we don't false-positive on a hypothetical sibling like
+    // `ContextOverflowRecovered` or `PostContextOverflow` after an
+    // addon-side rename.
+    if (typeof code === "string" && /::\s*ContextOverflow\s*\]/.test(code)) {
+        return true;
+    }
+    // Message-substring fallback for the bare `LlamaModel::processPromptImpl`
+    // path, which doesn't go through `StatusError::codeString()`. Match the
+    // two known C++-emitted formats only — broader substring would catch
+    // wrapper / cause-chain text that mentions overflow without being one.
+    const message = err.message;
+    return (typeof message === "string" &&
+        /(?:context overflow at prefill step|processPromptImpl: context overflow)/i.test(message));
+}
+/**
+ * Best-effort extraction of `promptTokens` / `ctxSize` from the addon
+ * error message. The C++ paths in `TextLlmContext.cpp` and
+ * `MtmdLlmContext.cpp` format both numbers into the message; the
+ * `LlamaModel::processPromptImpl` fallback path emits a bare
+ * `"<func>: context overflow\n"` with neither number. Returning
+ * `undefined` for either field is fine — `ContextOverflowError` holds
+ * them as optional and the message factory degrades gracefully.
+ */
+export function parseContextOverflowMessage(message) {
+    // "[TextLlm] context overflow at prefill step: prompt tokens N, max context tokens M\n"
+    // Same-clause separator (no `[^]*?` cross-newline walk) so a future
+    // wrapper that pastes overflow text alongside unrelated numbers can't
+    // produce a mismatched pair.
+    const longForm = message.match(/prompt tokens (\d+)[,\s]+max context tokens (\d+)/i);
+    if (longForm?.[1] && longForm[2]) {
+        return {
+            promptTokens: Number(longForm[1]),
+            ctxSize: Number(longForm[2]),
+        };
+    }
+    // "[TextLlm] context overflow at prefill step (N tokens, max M)\n"
+    // "[MtmdLlm] context overflow at prefill step (N tokens, max M)\n"
+    const shortForm = message.match(/\((\d+)\s+tokens,\s*max\s+(\d+)\)/i);
+    if (shortForm?.[1] && shortForm[2]) {
+        return {
+            promptTokens: Number(shortForm[1]),
+            ctxSize: Number(shortForm[2]),
+        };
+    }
+    return {};
+}

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

@@ -56,18 +56,23 @@ export declare const llmPlugin: {
                 diffusion: "diffusion";
                 tts: "tts";
                 ocr: "ocr";
+                vla: "vla";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
                 "nmtcpp-translation": "nmtcpp-translation";
                 "onnx-tts": "onnx-tts";
+                "tts-ggml": "tts-ggml";
                 "parakeet-transcription": "parakeet-transcription";
                 "onnx-ocr": "onnx-ocr";
                 "sdcpp-generation": "sdcpp-generation";
+                "ggml-vla": "ggml-vla";
+                "ggml-classification": "ggml-classification";
                 llm: "llm";
                 whisper: "whisper";
                 nmt: "nmt";
                 parakeet: "parakeet";
+                classification: "classification";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
     }, import("zod/v4/core").$strip>;
@@ -247,6 +252,7 @@ export declare const llmPlugin: {
                     timeToFirstToken: import("zod").ZodOptional<import("zod").ZodNumber>;
                     tokensPerSecond: import("zod").ZodOptional<import("zod").ZodNumber>;
                     cacheTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    promptTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
                     generatedTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
                     backendDevice: import("zod").ZodOptional<import("zod").ZodEnum<{
                         cpu: "cpu";