@qvac/sdk 0.15.0 → 0.16.0

package/dist/scripts/contract/build-model-type-maps.js

@@ -0,0 +1,16 @@
+import { ModelTypeAliases } from '../../schemas/model-types.js';
+import { ENGINE_TO_ADDON, LEGACY_ENGINE_TO_CANONICAL } from '../../schemas/engine-addon-map.js';
+function sortedEntries(record) {
+    const entries = Object.entries(record);
+    entries.sort(function (a, b) {
+        return a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0;
+    });
+    return Object.fromEntries(entries);
+}
+export function buildModelTypeMaps() {
+    return {
+        aliasToCanonical: sortedEntries(ModelTypeAliases),
+        engineToAddon: sortedEntries(ENGINE_TO_ADDON),
+        legacyEngineToCanonical: sortedEntries(LEGACY_ENGINE_TO_CANONICAL)
+    };
+}

package/dist/scripts/contract/build-models-registry.d.ts

@@ -0,0 +1,17 @@
+import type { ModelConstant } from '../../models/registry/index';
+/**
+ * JSON export of every named model constant in `@/models/registry`
+ * (`QWEN3_600M_INST_Q4`, `BCI_EMBEDDER`, ...) — the same constants JS
+ * consumers import directly and pass as `modelSrc`
+ * (`loadModel({ modelSrc: QWEN3_600M_INST_Q4, ... })`). Only the ~440
+ * promoted-to-a-named-export entries are included, not the full ~780-entry
+ * `models` array — entries without a name aren't meant for direct import in
+ * JS either.
+ *
+ * This is a separate artifact from schema.json/manifest.json: it's a static
+ * data catalog, not part of the RPC wire contract, but it lives alongside
+ * them in contract/ for the same reason — a language-neutral build artifact
+ * downstream client generators (starting with Python) consume.
+ */
+export declare function buildModelsRegistry(): Record<string, ModelConstant>;
+//# sourceMappingURL=build-models-registry.d.ts.map

package/dist/scripts/contract/build-models-registry.js

@@ -0,0 +1,31 @@
+import * as registry from '../../models/registry/index.js';
+function isModelConstant(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        typeof value.src === 'string');
+}
+/**
+ * JSON export of every named model constant in `@/models/registry`
+ * (`QWEN3_600M_INST_Q4`, `BCI_EMBEDDER`, ...) — the same constants JS
+ * consumers import directly and pass as `modelSrc`
+ * (`loadModel({ modelSrc: QWEN3_600M_INST_Q4, ... })`). Only the ~440
+ * promoted-to-a-named-export entries are included, not the full ~780-entry
+ * `models` array — entries without a name aren't meant for direct import in
+ * JS either.
+ *
+ * This is a separate artifact from schema.json/manifest.json: it's a static
+ * data catalog, not part of the RPC wire contract, but it lives alongside
+ * them in contract/ for the same reason — a language-neutral build artifact
+ * downstream client generators (starting with Python) consume.
+ */
+export function buildModelsRegistry() {
+    const namespace = registry;
+    const entries = Object.entries(namespace).filter(function (entry) {
+        return isModelConstant(entry[1]);
+    });
+    entries.sort(function (a, b) {
+        return a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0;
+    });
+    return Object.fromEntries(entries);
+}

package/dist/scripts/contract/plugin-contract.d.ts

@@ -0,0 +1,23 @@
+import type { QvacPlugin } from '../../schemas/index';
+export interface PluginHandlerContract {
+    name: string;
+    streaming: boolean;
+    requestSchema: unknown;
+    responseSchema: unknown;
+}
+export interface PluginContract {
+    modelType: string;
+    displayName?: string;
+    handlers: PluginHandlerContract[];
+}
+/**
+ * Wire contract of one registered plugin: JSON Schema per handler, in the
+ * same wire shape the built-in contract export uses (requests as input
+ * shape, responses as output shape). Custom plugins register at runtime, so
+ * unlike the built-in contract this isn't emitted by `contract:export` —
+ * plugin authors (or app builds) run `scripts/export-plugin-contract.ts` on
+ * their plugin module and feed the result to the Python generator's
+ * `--plugin` input to get typed clients for their handlers.
+ */
+export declare function buildPluginContract(plugin: QvacPlugin): PluginContract;
+//# sourceMappingURL=plugin-contract.d.ts.map

package/dist/scripts/contract/plugin-contract.js

@@ -0,0 +1,28 @@
+import { toWireJsonSchema } from './build-contract.js';
+/**
+ * Wire contract of one registered plugin: JSON Schema per handler, in the
+ * same wire shape the built-in contract export uses (requests as input
+ * shape, responses as output shape). Custom plugins register at runtime, so
+ * unlike the built-in contract this isn't emitted by `contract:export` —
+ * plugin authors (or app builds) run `scripts/export-plugin-contract.ts` on
+ * their plugin module and feed the result to the Python generator's
+ * `--plugin` input to get typed clients for their handlers.
+ */
+export function buildPluginContract(plugin) {
+    const handlers = Object.entries(plugin.handlers).map(function ([name, handler]) {
+        return {
+            name,
+            streaming: handler.streaming === true,
+            requestSchema: toWireJsonSchema(handler.requestSchema, 'input', `${plugin.modelType}.${name}.request`),
+            responseSchema: toWireJsonSchema(handler.responseSchema, 'output', `${plugin.modelType}.${name}.response`)
+        };
+    });
+    handlers.sort(function (a, b) {
+        return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+    });
+    return {
+        modelType: plugin.modelType,
+        ...(plugin.displayName && { displayName: plugin.displayName }),
+        handlers
+    };
+}

package/dist/scripts/export-contract.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=export-contract.d.ts.map

package/dist/scripts/export-contract.js

@@ -0,0 +1,27 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { contractDir, renderContractFiles } from './contract/build-contract.js';
+const checkOnly = process.argv.includes('--check');
+const files = await renderContractFiles();
+await mkdir(contractDir, { recursive: true });
+let stale = false;
+for (const [name, content] of Object.entries(files)) {
+    const filePath = fileURLToPath(new URL(name, contractDir));
+    if (checkOnly) {
+        const existing = await readFile(filePath, 'utf8').catch(function () {
+            return null;
+        });
+        if (existing !== content) {
+            console.error(`contract/${name} is ${existing === null ? 'missing' : 'out of date'}`);
+            stale = true;
+        }
+    }
+    else {
+        await writeFile(filePath, content);
+        console.log(`wrote contract/${name}`);
+    }
+}
+if (stale) {
+    console.error("Contract artifacts are stale. Run 'bun run contract:export' and commit the result.");
+    process.exit(1);
+}

package/dist/scripts/export-plugin-contract.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=export-plugin-contract.d.ts.map

package/dist/scripts/export-plugin-contract.js

@@ -0,0 +1,18 @@
+import { writeFile } from 'node:fs/promises';
+import { pathToFileURL } from 'node:url';
+import { buildPluginContract } from './contract/plugin-contract.js';
+// Usage: tsx scripts/export-plugin-contract.ts <plugin-module> <out.json>
+// The plugin module's default export must be a definePlugin(...) value.
+const [modulePath, outPath] = process.argv.slice(2);
+if (!modulePath || !outPath) {
+    console.error('usage: export-plugin-contract <plugin-module> <out.json>');
+    process.exit(1);
+}
+const imported = (await import(pathToFileURL(modulePath).href));
+if (!imported.default) {
+    console.error(`${modulePath} has no default export`);
+    process.exit(1);
+}
+const contract = buildPluginContract(imported.default);
+await writeFile(outPath, JSON.stringify(contract, null, 2) + '\n');
+console.log(`wrote ${outPath} (${contract.handlers.length} handlers)`);

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

@@ -52,10 +52,10 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 });
 import { getModelEntry } from '../registry/model-registry.js';
 import { translateServerParamsSchema, normalizeModelType, ModelType, AFRICAN_LANGUAGES_MAP } from '../../../schemas/index.js';
-import { getLangName } from '@qvac/langdetect-text';
+import { getLangName, detectOne } from '@qvac/langdetect-text';
 import { nowMs } from '../../../profiling/index.js';
 import { buildStreamResult } from '../../../profiling/model-execution.js';
-import { ModelIsDelegatedError, ModelNotFoundError, ModelTypeMismatchError } from '../../../utils/errors-server.js';
+import { ModelIsDelegatedError, ModelNotFoundError, ModelTypeMismatchError, TranslationFailedError } from '../../../utils/errors-server.js';
 import { getRequestRegistry, withRequestContext } from '../runtime/index.js';
 import { generateServerRequestId } from '../runtime/request-id.js';
 import { getServerLogger } from '../../../logging/index.js';
@@ -101,9 +101,22 @@ export async function* translate(params, requestId) {
             }
         }
         const isLlm = canonicalModelType === ModelType.llamacppCompletion;
-        const from = isLlm ? params.from : undefined;
+        let from = isLlm ? params.from : undefined;
         const to = isLlm ? params.to : undefined;
         const context = isLlm ? params.context : undefined;
+        // Auto-detect the source language when the caller didn't pass `from` (LLM
+        // only). This used to run in each client; moving it here gives every
+        // language binding one detector instead of each shipping its own (lingua in
+        // Python vs langdetect-text in JS drifted on the same input). Store the
+        // detected code — not the language name — so the explicit-`from` and
+        // detected paths feed getLanguage() identically.
+        if (isLlm && !from) {
+            const detected = detectOne(text);
+            if (detected.code === 'und' || detected.language === 'Undetermined') {
+                throw new TranslationFailedError("Could not detect the source language. Please specify the 'from' parameter explicitly.");
+            }
+            from = detected.code;
+        }
         const afriquePrompt = isLlm && (isAfrican(from) || isAfrican(to));
         translateServerParamsSchema.parse(params);
         const fromLanguage = getLanguage(from);

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

@@ -1,3 +1,4 @@
+import bciAddonLogging from '@qvac/bci-whispercpp/addonLogging';
 import { type CreateModelParams, type PluginModelResult } from '../../../../schemas/index';
 import { resolveBciConfig } from './resolve-config';
 export declare const bciPlugin: {
@@ -164,7 +165,7 @@ export declare const bciPlugin: {
         }, import("zod/v4/core").$strip>>;
     };
     logging: {
-        module: import("@qvac/bci-whispercpp/addonLogging").AddonLogging;
+        module: typeof bciAddonLogging;
         namespace: "bci-whispercpp-transcription";
     };
 };

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

@@ -1,23 +1,11 @@
 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://')) {
-        const { key } = hyperdriveUrlSchema.parse(modelSrc);
-        return `pear://${key}/${OCR_DETECTOR_FILENAME}`;
-    }
-    if (modelSrc.startsWith('registry://')) {
-        return OCR_CRAFT.src;
-    }
-    return undefined;
-}
+import { resolveOcrConfig } from './resolve-config.js';
 function createOCRModel(modelId, detectorPath, recognizerPath, ocrConfig) {
     const logger = createStreamLogger(modelId, ModelType.ggmlOcr);
     registerAddonLogger(modelId, ModelType.ggmlOcr, logger);
@@ -66,16 +54,7 @@ export const ocrPlugin = definePlugin({
     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');
-        }
-        const detectorModelPath = await ctx.resolveModelPath(detectorSrc);
-        return {
-            config: ocrConfig,
-            artifacts: { detectorModelPath }
-        };
+        return resolveOcrConfig(cfg, ctx);
     },
     createModel(params) {
         const ocrConfig = (params.modelConfig ?? {});

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

@@ -0,0 +1,6 @@
+import { type OCRConfig, type ResolveContext, type ResolveResult } from '../../../../schemas/index';
+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

@@ -0,0 +1,73 @@
+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/plugin.d.ts

@@ -53,6 +53,11 @@ export declare const vlaPlugin: {
                     discrete: "discrete";
                     continuous: "continuous";
                 }>>;
+                imageInputMode: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    pixels: "pixels";
+                    patches: "patches";
+                }>>;
+                imagePatchElems: import("zod").ZodOptional<import("zod").ZodNumber>;
             }, import("zod/v4/core").$strip>;
             backendName: import("zod").ZodNullable<import("zod").ZodString>;
         }, import("zod/v4/core").$strip>>;

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

@@ -16,7 +16,7 @@ function wrapVlaModel(inner, loadOpts) {
 }
 export const vlaPlugin = definePlugin({
     modelType: ModelType.ggmlVla,
-    displayName: 'VLA (SmolVLA / π₀.₅ ggml)',
+    displayName: 'VLA (SmolVLA / π₀.₅ / GR00T ggml)',
     addonPackage: ADDON_VLA,
     loadConfigSchema: vlaConfigSchema,
     createModel(params) {

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

@@ -2,7 +2,7 @@ import { TOOLS_MODE } from '../../../../../schemas/tools.js';
 import { logCacheDisabled, logCacheInit, logCacheSave, logMessagesToAddon } from './cache-logger.js';
 import { extractSystemPrompt, getCurrentCacheInfo } from '../../../ops/kv-cache-utils.js';
 import { getModel, getModelConfig } from '../../../registry/model-registry.js';
-import { decideCachedHistorySlice } from './kv-cache-state.js';
+import { decideCachedHistorySlice, shouldCommitCachedTurn } from './kv-cache-state.js';
 import { createKvCacheSession, generateConfigHash } from './kv-cache-session.js';
 import { appendToolsToHistory, detectToolDialect, prependToolsToHistory } from '../../../../utils/tool-integration.js';
 import { parseToolCalls } from '../../../../utils/tools/index.js';
@@ -15,22 +15,6 @@ import { buildStreamResult } from '../../../../../profiling/model-execution.js';
 import { normalizeCompletionStats } from './completion-stats.js';
 import fs from 'bare-fs';
 const logger = getServerLogger();
-/**
- * Decide whether a completed turn earned the right to record its kv-cache
- * boundary. A `savedCount` is only safe to write when the turn ran to
- * completion AND produced at least one token — anything else (cancelled
- * mid-decode, zero-token reply, early EOS) leaves the on-disk cache file
- * in an unknown state relative to `history.length + 1`, and a stale entry
- * would slice the next turn's history down to an empty payload.
- *
- * Replaces the pre-0.11.0 `shouldRecordSavedCount(wasCancelled, ...)` with
- * a signal-driven check that reads directly from the request's
- * `AbortSignal`. The local helper keeps the call sites in
- * `completion-stream.ts` honest without importing the registry every time.
- */
-function shouldCommitTurn(signal, producedTokens) {
-    return !signal.aborted && producedTokens;
-}
 function transformMessage(message) {
     const transformed = [];
     // Check if it's a tool definition (has type: "function")
@@ -338,11 +322,17 @@ export async function* completion(params, opts) {
     /* cacheExists */ true, history, dynamicTools ? tools : undefined);
     logMessagesToAddon(messagesToSend, 'PROMPT_SEND');
     const result = yield* processModelResponse(model, messagesToSend, tools, mergedGenerationParams, { cacheKey: turn.cachePath, saveCacheToDisk: true }, dialect);
+    const shouldCommitTurn = shouldCommitCachedTurn({
+        aborted: signal.aborted,
+        producedTokens: result.producedTokens,
+        generatedTokens: result.stats?.generatedTokens,
+        predict: mergedGenerationParams?.predict ?? modelConfig.predict
+    });
     if (typeof kvCache === 'string') {
         // Custom-key path: the addon wrote the new cache state inline at
         // the same path. Either commit (records the boundary, suppresses
         // rollback) or fall through to the deferred rollback.
-        if (shouldCommitTurn(signal, result.producedTokens)) {
+        if (shouldCommitTurn) {
             await session.commitTurn(turn, {
                 kind: 'static',
                 messageCount: history.length + 1
@@ -362,10 +352,9 @@ export async function* completion(params, opts) {
         logger.warn(`[kv-cache] Auto cache tool-call turn; rolling back to avoid disk leak. path=${turn.cachePath}`);
         return result;
     }
-    if (!shouldCommitTurn(signal, result.producedTokens)) {
-        // Cancelled or zero-token turn — the addon wrote the file but its
-        // contents don't correspond to a clean turn boundary. Let the
-        // deferred rollback unlink it.
+    if (!shouldCommitTurn) {
+        // Cancelled, zero-token, or budget-exhausted turns do not establish
+        // a trustworthy message boundary.
         return result;
     }
     const savedHistory = buildAutoCacheSaveHistory(history.map((msg) => ({

package/dist/server/bare/plugins/llamacpp-completion/ops/kv-cache-state.d.ts

@@ -32,6 +32,13 @@ export interface HistorySliceDecision {
      */
     clearStaleCount: boolean;
 }
+interface CacheCommitContext {
+    aborted: boolean;
+    producedTokens: boolean;
+    generatedTokens?: number | undefined;
+    predict?: number | undefined;
+}
+export declare function shouldCommitCachedTurn(context: CacheCommitContext): boolean;
 /**
  * Pure slice decision for `prepareMessagesForCache`.
  *
@@ -46,4 +53,5 @@ export interface HistorySliceDecision {
  * than handing the model an empty payload.
  */
 export declare function decideCachedHistorySlice(savedCount: number, cacheExists: boolean, history: HistoryMessage[]): HistorySliceDecision;
+export {};
 //# sourceMappingURL=kv-cache-state.d.ts.map

package/dist/server/bare/plugins/llamacpp-completion/ops/kv-cache-state.js

@@ -14,6 +14,14 @@
  * layers (saved counts, init flags, on-disk files). Only the pure
  * slice-decision helper remains here.
  */
+export function shouldCommitCachedTurn(context) {
+    const { aborted, producedTokens, generatedTokens, predict } = context;
+    const stoppedByBudget = predict !== undefined &&
+        predict > 0 &&
+        generatedTokens !== undefined &&
+        generatedTokens >= predict;
+    return !aborted && producedTokens && !stoppedByBudget;
+}
 /**
  * Pure slice decision for `prepareMessagesForCache`.
  *

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

@@ -15,7 +15,12 @@ export declare const llmPlugin: {
         predict: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<-1>, import("zod").ZodLiteral<-2>, import("zod").ZodNumber]>>;
         system_prompt: import("zod").ZodOptional<import("zod").ZodString>;
         no_mmap: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        verbosity: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<0>, import("zod").ZodLiteral<1>, import("zod").ZodLiteral<2>, import("zod").ZodLiteral<3>]>>;
+        verbosity: import("zod").ZodOptional<import("zod").ZodEnum<{
+            readonly ERROR: 0;
+            readonly WARN: 1;
+            readonly INFO: 2;
+            readonly DEBUG: 3;
+        }>>;
         presence_penalty: import("zod").ZodOptional<import("zod").ZodNumber>;
         frequency_penalty: import("zod").ZodOptional<import("zod").ZodNumber>;
         repeat_penalty: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -220,7 +225,7 @@ export declare const llmPlugin: {
                                 integer: "integer";
                             }>;
                             description: import("zod").ZodOptional<import("zod").ZodString>;
-                            enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                            enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull]>>>;
                         }, import("zod/v4/core").$strip>>;
                         required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
                     }, import("zod/v4/core").$strip>;
@@ -343,7 +348,7 @@ export declare const llmPlugin: {
                             integer: "integer";
                         }>;
                         description: import("zod").ZodOptional<import("zod").ZodString>;
-                        enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                        enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull]>>>;
                     }, import("zod/v4/core").$strip>>;
                     required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
                 }, import("zod/v4/core").$strip>;

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

@@ -37,7 +37,12 @@ export declare const embeddingsPlugin: {
             row: "row";
         }>>;
         tensorSplit: import("zod").ZodOptional<import("zod").ZodString>;
-        verbosity: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<0>, import("zod").ZodLiteral<1>, import("zod").ZodLiteral<2>, import("zod").ZodLiteral<3>]>>;
+        verbosity: import("zod").ZodOptional<import("zod").ZodEnum<{
+            readonly ERROR: 0;
+            readonly WARN: 1;
+            readonly INFO: 2;
+            readonly DEBUG: 3;
+        }>>;
         openclCacheDir: import("zod").ZodOptional<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>;
     createModel(params: CreateModelParams): PluginModelResult;

package/dist/server/bare/plugins/sdcpp-generation/ops/video.d.ts

@@ -1,3 +1,5 @@
-import type { VideoRequest, VideoStreamResponse } from '../../../../../schemas/sdcpp-config';
+import { VideoStableDiffusion } from '@qvac/diffusion-cpp';
+import { type VideoRequest, type VideoStreamResponse } from '../../../../../schemas/sdcpp-config';
+export declare function markLtxVideoModel(model: VideoStableDiffusion): void;
 export declare function video(request: VideoRequest): AsyncGenerator<VideoStreamResponse>;
 //# sourceMappingURL=video.d.ts.map

package/dist/server/bare/plugins/sdcpp-generation/ops/video.js

@@ -55,8 +55,32 @@ import { getServerLogger } from '../../../../../logging/index.js';
 import { getModel, getModelEntry } from '../../../registry/model-registry.js';
 import { getRequestRegistry, withRequestContext } from '../../../runtime/index.js';
 import { generateServerRequestId } from '../../../runtime/request-id.js';
-import { ModelOperationNotSupportedError } from '../../../../../utils/errors-server.js';
+import { ModelOperationNotSupportedError, PluginRequestValidationFailedError } from '../../../../../utils/errors-server.js';
+import { formatZodError } from '../../../../../utils/zod-error.js';
 import { ModelType } from '../../../../../schemas/index.js';
+import { ltxVideoRequestSchema } from '../../../../../schemas/sdcpp-config.js';
+const ltxVideoModels = new WeakSet();
+export function markLtxVideoModel(model) {
+    ltxVideoModels.add(model);
+}
+function parseLtxVideoRequest(request) {
+    const result = ltxVideoRequestSchema.safeParse(request);
+    if (!result.success) {
+        throw new PluginRequestValidationFailedError('videoStream', formatZodError(result.error));
+    }
+}
+// The addon reports `hasAudio` as a numeric flag (1/0); the SDK surfaces it as
+// a boolean so consumers get a readable `stats.hasAudio` instead of a magic
+// number. Everything else passes through and is validated client-side.
+function toVideoStats(stats) {
+    if (!stats)
+        return undefined;
+    const { hasAudio, ...rest } = stats;
+    return {
+        ...rest,
+        ...(hasAudio !== undefined && { hasAudio: hasAudio !== 0 })
+    };
+}
 // The diffusion plugin instantiates `VideoStableDiffusion` when the model is
 // loaded with `modelConfig.mode === "video"` and `ImgStableDiffusion` (or
 // `EsrganUpscaler`) otherwise. Those have no video `run()` shape, so we refuse
@@ -80,6 +104,8 @@ export async function* video(request) {
         }), true);
         const requestLogger = withRequestContext(getServerLogger(), ctx);
         const model = asVideoModel(getModel(request.modelId), request.modelId);
+        if (ltxVideoModels.has(model))
+            parseLtxVideoRequest(request);
         const onAbort = () => {
             model.cancel().catch((err) => {
                 requestLogger.warn(`[cancel] model.cancel() rejected during abort for modelId=${request.modelId}: ${err instanceof Error ? err.message : String(err)}`);
@@ -148,6 +174,9 @@ export async function* video(request) {
             ...(request.vae_tile_overlap !== undefined && {
                 vae_tile_overlap: request.vae_tile_overlap
             }),
+            ...(request.temporal_tiling !== undefined && {
+                temporal_tiling: request.temporal_tiling
+            }),
             ...(request.cache_mode !== undefined && { cache_mode: request.cache_mode }),
             ...(request.cache_preset !== undefined && {
                 cache_preset: request.cache_preset
@@ -188,7 +217,7 @@ export async function* video(request) {
         yield {
             type: 'videoStream',
             done: true,
-            stats: responseWithStats.stats ?? undefined
+            stats: toVideoStats(responseWithStats.stats)
         };
     }
     catch (e_1) {