@qvac/sdk 0.7.0 → 0.8.0

package/dist/server/bare/ops/load-model.js

@@ -1,27 +1,32 @@
-import { loadModelServerParamsSchema, ModelType, normalizeModelType, } from "../../../schemas/index.js";
+import { loadModelServerParamsSchema, normalizeModelType, } from "../../../schemas/index.js";
+import { nowMs } from "../../../profiling/clock.js";
 import { isModelLoaded, registerModel, } from "../registry/model-registry.js";
 import { startLogBuffering, stopLogBufferingWithTimeout, } from "../registry/logging-stream-registry.js";
 import { detectShardedModel, generateShardFilenames, validateShardedModelCache, } from "../../utils/index.js";
-import { ModelLoadFailedError, PluginNotFoundError, ModelFileNotFoundError, ModelFileNotFoundInDirError, ModelFileLocateFailedError, } from "../../../utils/errors-server.js";
+import { PluginNotFoundError, ModelFileNotFoundError, ModelFileNotFoundInDirError, ModelFileLocateFailedError, } from "../../../utils/errors-server.js";
 import { getPlugin } from "../../plugins/index.js";
 import { promises as fsPromises } from "bare-fs";
 import path from "bare-path";
 import { getServerLogger } from "../../../logging/index.js";
 const logger = getServerLogger();
-export async function loadModel(params) {
-    const { modelId, modelPath, options, projectionModelPath, vadModelPath, detectorModelPath, modelName, } = loadModelServerParamsSchema.parse(params);
-    const { modelConfig, modelType: rawModelType } = options;
+export async function loadModel(params, options) {
+    const { modelId, modelPath, options: modelOptions, artifacts, modelName } = loadModelServerParamsSchema.parse(params);
+    const { modelConfig, modelType: rawModelType } = modelOptions;
     // Normalize modelType to canonical form (handles aliases and custom types)
     const modelType = normalizeModelType(rawModelType);
     // Check if model is already loaded
     if (isModelLoaded(modelId)) {
         logger.info(`${modelType} model ${modelId} is already loaded`);
-        return;
+        return {};
     }
     // Detect if sharded model
     const modelFileName = path.basename(modelPath);
     const shardInfo = detectShardedModel(modelFileName);
     const isShardedModel = shardInfo.isSharded;
+    const plugin = getPlugin(modelType);
+    if (!plugin) {
+        throw new PluginNotFoundError(modelType);
+    }
     if (isShardedModel) {
         // For sharded models, validate all shards and tensors.txt exist
         const shardDir = path.dirname(modelPath);
@@ -31,9 +36,8 @@ export async function loadModel(params) {
             throw new ModelFileNotFoundError(`Missing shards or ${shardInfo.baseFilename}.tensors.txt. Expected ${numberedShards.length} shard files + tensors.txt in ${shardDir}`);
         }
     }
-    else if (modelType !== ModelType.onnxTts) {
+    else if (!plugin.skipPrimaryModelPathValidation) {
         // For non-sharded models, validate single file exists
-        // Skip for TTS - it uses multiple paths from modelConfig (resolved by plugin.resolveConfig)
         try {
             const modelDir = path.dirname(modelPath);
             const modelFile = path.basename(modelPath);
@@ -47,40 +51,35 @@ export async function loadModel(params) {
             throw new ModelFileLocateFailedError(modelType, modelPath, error);
         }
     }
-    if (modelType === ModelType.onnxOcr && !detectorModelPath) {
-        throw new ModelLoadFailedError("Detector model required for OCR. Use a hyperdrive source or provide detectorModelSrc");
-    }
-    const plugin = getPlugin(modelType);
-    if (!plugin) {
-        throw new PluginNotFoundError(modelType);
-    }
-    // Build artifacts map for plugin
-    // Note: TTS paths are in modelConfig (resolved by plugin.resolveConfig), not artifacts
-    const artifacts = {};
-    if (projectionModelPath)
-        artifacts["projectionModelPath"] = projectionModelPath;
-    if (vadModelPath)
-        artifacts["vadModelPath"] = vadModelPath;
-    if (detectorModelPath)
-        artifacts["detectorModelPath"] = detectorModelPath;
-    const result = plugin.createModel({
-        modelId,
-        modelPath,
-        modelConfig: modelConfig,
-        modelName,
-        artifacts: Object.keys(artifacts).length > 0 ? artifacts : undefined,
-    });
     logger.info(`${modelType}: Loading model ${modelId}...`);
     startLogBuffering(modelId);
-    await result.model.load(false);
-    logger.info(`${modelType} model ${modelId} loaded`);
-    stopLogBufferingWithTimeout(modelId);
-    registerModel(modelId, {
-        model: result.model,
-        path: modelPath,
-        config: modelConfig,
-        modelType: modelType,
-        name: modelName,
-        loader: result.loader,
-    });
+    try {
+        const initStart = options?.collectTiming ? nowMs() : 0;
+        const result = plugin.createModel({
+            modelId,
+            modelPath,
+            modelConfig: modelConfig,
+            modelName,
+            artifacts,
+        });
+        await result.model.load(false);
+        const modelInitializationTimeMs = options?.collectTiming
+            ? nowMs() - initStart
+            : undefined;
+        logger.info(`${modelType} model ${modelId} loaded`);
+        registerModel(modelId, {
+            model: result.model,
+            path: modelPath,
+            config: modelConfig,
+            modelType: modelType,
+            name: modelName,
+            loader: result.loader,
+        });
+        return modelInitializationTimeMs !== undefined
+            ? { timing: { modelInitializationTimeMs } }
+            : {};
+    }
+    finally {
+        stopLogBufferingWithTimeout(modelId);
+    }
 }

package/dist/server/bare/ops/transcribe.d.ts

@@ -0,0 +1,3 @@
+import { type TranscribeParams } from "../../../schemas/index";
+export declare function transcribe(params: TranscribeParams): AsyncGenerator<string, void, void>;
+//# sourceMappingURL=transcribe.d.ts.map

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

@@ -0,0 +1,75 @@
+import { getModel, getModelConfig, getModelEntry, } from "../registry/model-registry.js";
+import { ModelType, } from "../../../schemas/index.js";
+import { createAudioStream } from "../utils/audio-input.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
+const SILENCE_MARKERS = {
+    [ModelType.whispercppTranscription]: "[BLANK_AUDIO]",
+    [ModelType.parakeetTranscription]: "[No speech detected]",
+};
+function getEngineModelType(modelId) {
+    const entry = getModelEntry(modelId);
+    return entry?.local?.modelType ?? "";
+}
+function getAudioFormat(modelId, engineType) {
+    if (engineType === ModelType.whispercppTranscription) {
+        const config = getModelConfig(modelId);
+        return config.audio_format || "s16le";
+    }
+    return "s16le";
+}
+async function applyPrompt(modelId, prompt, engineType) {
+    if (engineType !== ModelType.whispercppTranscription || !prompt) {
+        return null;
+    }
+    const model = getModel(modelId);
+    if (typeof model.reload !== "function")
+        return null;
+    const originalConfig = getModelConfig(modelId);
+    const updatedConfig = { ...originalConfig, initial_prompt: prompt };
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { contextParams: _, miscConfig, ...whisperParams } = updatedConfig;
+    await model.reload({
+        whisperConfig: whisperParams,
+        ...(miscConfig && { miscConfig }),
+    });
+    return originalConfig;
+}
+async function restorePrompt(modelId, originalConfig) {
+    const model = getModel(modelId);
+    if (typeof model.reload !== "function")
+        return;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { contextParams: _, miscConfig, ...whisperParams } = originalConfig;
+    await model.reload({
+        whisperConfig: { ...whisperParams, initial_prompt: "" },
+        ...(miscConfig && { miscConfig }),
+    });
+}
+export async function* transcribe(params) {
+    const { modelId } = params;
+    const engineType = getEngineModelType(modelId);
+    const silenceMarker = SILENCE_MARKERS[engineType] ?? "";
+    const audioFormat = getAudioFormat(modelId, engineType);
+    const originalConfig = await applyPrompt(modelId, params.prompt, engineType);
+    try {
+        const model = getModel(modelId);
+        const audioStream = await createAudioStream(params.audioChunk, audioFormat);
+        const response = await model.run(audioStream);
+        for await (const output of response.iterate()) {
+            logger.debug("Streaming Transcription Update:", output);
+            const text = output
+                .filter((chunk) => !silenceMarker || !chunk.text.includes(silenceMarker))
+                .map((chunk) => chunk.text)
+                .join("");
+            if (text.trim()) {
+                yield text;
+            }
+        }
+    }
+    finally {
+        if (originalConfig) {
+            await restorePrompt(modelId, originalConfig);
+        }
+    }
+}

package/dist/server/bare/ops/translate.d.ts

@@ -1,3 +1,5 @@
 import { type TranslateParams, type TranslationStats } from "../../../schemas/index";
+export declare function getLanguage(code: string | undefined): string;
+export declare function isAfrican(code: string | undefined): boolean;
 export declare function translate(params: TranslateParams): AsyncGenerator<string, TranslationStats | undefined, unknown>;
 //# sourceMappingURL=translate.d.ts.map

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

@@ -1,12 +1,17 @@
 import { getModel } from "../registry/model-registry.js";
-import { translateServerParamsSchema, normalizeModelType, ModelType, } from "../../../schemas/index.js";
+import { translateServerParamsSchema, normalizeModelType, ModelType, AFRICAN_LANGUAGES_MAP, } from "../../../schemas/index.js";
 import { getLangName } from "@qvac/langdetect-text";
-function getLanguage(code) {
+export function getLanguage(code) {
     if (!code)
         return "";
+    if (AFRICAN_LANGUAGES_MAP.has(code))
+        return AFRICAN_LANGUAGES_MAP.get(code);
     const fullName = getLangName(code);
     return fullName ?? code.toUpperCase();
 }
+export function isAfrican(code) {
+    return !!code && AFRICAN_LANGUAGES_MAP.has(code);
+}
 export async function* translate(params) {
     const { modelId, text, modelType: inputModelType } = params;
     const canonicalModelType = normalizeModelType(inputModelType);
@@ -14,6 +19,7 @@ export async function* translate(params) {
     const from = isLlm ? params.from : undefined;
     const to = isLlm ? params.to : undefined;
     const context = isLlm ? params.context : undefined;
+    const afriquePrompt = isLlm && (isAfrican(from) || isAfrican(to));
     translateServerParamsSchema.parse(params);
     const model = getModel(modelId);
     const fromLanguage = getLanguage(from);
@@ -47,8 +53,10 @@ export async function* translate(params) {
         ? singleText
         : [
             {
-                role: "system",
-                content: `${context ? `${context}. ` : ""}Translate the following text from ${fromLanguage} into ${toLanguage}. Only output the translation, nothing else.\n\n${fromLanguage}: ${singleText}\n${toLanguage}:`,
+                role: afriquePrompt ? "user" : "system",
+                content: afriquePrompt
+                    ? `Translate ${fromLanguage} to ${toLanguage}.\n${fromLanguage}: ${singleText}\n${toLanguage}:`
+                    : `${context ? `${context}. ` : ""}Translate the following text from ${fromLanguage} into ${toLanguage}. Only output the translation, nothing else.\n\n${fromLanguage}: ${singleText}\n${toLanguage}:`,
             },
         ];
     const response = await model.run(input);

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

@@ -1,6 +1,7 @@
 export { llmPlugin } from "./llamacpp-completion/plugin";
 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 { ocrPlugin } from "./onnx-ocr/plugin";

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

@@ -1,6 +1,7 @@
 export { llmPlugin } from "./llamacpp-completion/plugin.js";
 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 { ocrPlugin } from "./onnx-ocr/plugin.js";

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

@@ -1,6 +1,7 @@
-import type { CompletionParams, CompletionStats, Tool, ToolCall, ToolCallEvent } from "../../../../../schemas/index";
+import type { CompletionParams, CompletionStats, GenerationParams, Tool, ToolCall, ToolCallEvent } from "../../../../../schemas/index";
 export declare function completion(params: CompletionParams & {
     tools?: Tool[];
+    generationParams?: GenerationParams;
 }): AsyncGenerator<{
     token: string;
     toolCallEvent?: ToolCallEvent;

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

@@ -78,8 +78,10 @@ function prepareMessagesForCache(cachePathToUse, cacheExists, history) {
         ...transformedHistoryWithoutSystem,
     ];
 }
-async function* processModelResponse(model, messagesToSend, shouldSaveCache, tools) {
-    const response = await model.run(messagesToSend);
+async function* processModelResponse(model, messagesToSend, shouldSaveCache, tools, generationParams) {
+    const runFn = model.run.bind(model);
+    const runOptions = generationParams ? { generationParams } : undefined;
+    const response = await runFn(messagesToSend, runOptions);
     let accumulatedText = "";
     const emittedToolCallPositions = new Set();
     let toolCallsResult = [];
@@ -114,7 +116,7 @@ async function* processModelResponse(model, messagesToSend, shouldSaveCache, too
     return { stats, toolCalls: toolCallsResult };
 }
 export async function* completion(params) {
-    const { history, modelId, kvCache, tools } = params;
+    const { history, modelId, kvCache, tools, generationParams } = params;
     const modelConfig = getModelConfig(modelId);
     const toolsEnabled = modelConfig.tools === true;
     let historyWithTools = history;
@@ -143,7 +145,7 @@ export async function* completion(params) {
             }
             const messagesToSend = prepareMessagesForCache(cachePathToUse, cacheExists, history);
             logMessagesToAddon(messagesToSend, "PROMPT_SEND");
-            return yield* processModelResponse(model, messagesToSend, true, tools);
+            return yield* processModelResponse(model, messagesToSend, true, tools, generationParams);
         }
         else {
             // Auto-generate cache key based on conversation history
@@ -167,7 +169,7 @@ export async function* completion(params) {
             }
             const messagesToSend = prepareMessagesForCache(cachePathToUse, cacheExists, history);
             logMessagesToAddon(messagesToSend, "PROMPT_SEND");
-            const result = yield* processModelResponse(model, messagesToSend, true, tools);
+            const result = yield* processModelResponse(model, messagesToSend, true, tools, generationParams);
             //If there was an existing cache, we rename it with new hash that includes the current message
             if (existingCache !== null &&
                 existingCache.cachePath !== currentCacheInfo.cachePath) {
@@ -179,6 +181,6 @@ export async function* completion(params) {
     else {
         logCacheDisabled();
         logMessagesToAddon(transformedHistory, "NO_CACHE");
-        return yield* processModelResponse(model, transformedHistory, false, tools);
+        return yield* processModelResponse(model, transformedHistory, false, tools, generationParams);
     }
 }

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

@@ -1,8 +1,103 @@
-import { type CreateModelParams, type PluginModelResult } from "../../../../schemas/index";
+import { type CreateModelParams, type PluginModelResult, type ResolveContext, type LlmConfigInput } from "../../../../schemas/index";
 export declare const llmPlugin: {
     modelType: "llamacpp-completion";
     displayName: string;
-    addonPackage: string;
+    addonPackage: "@qvac/llm-llamacpp";
+    loadConfigSchema: import("zod").ZodObject<{
+        ctx_size: import("zod").ZodOptional<import("zod").ZodNumber>;
+        temp: import("zod").ZodOptional<import("zod").ZodNumber>;
+        top_p: import("zod").ZodOptional<import("zod").ZodNumber>;
+        top_k: import("zod").ZodOptional<import("zod").ZodNumber>;
+        seed: import("zod").ZodOptional<import("zod").ZodNumber>;
+        gpu_layers: import("zod").ZodOptional<import("zod").ZodNumber>;
+        lora: import("zod").ZodOptional<import("zod").ZodString>;
+        device: import("zod").ZodOptional<import("zod").ZodString>;
+        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>]>>;
+        presence_penalty: import("zod").ZodOptional<import("zod").ZodNumber>;
+        frequency_penalty: import("zod").ZodOptional<import("zod").ZodNumber>;
+        repeat_penalty: import("zod").ZodOptional<import("zod").ZodNumber>;
+        stop_sequences: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        n_discarded: import("zod").ZodOptional<import("zod").ZodNumber>;
+        tools: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        projectionModelSrc: 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<{
+                "llamacpp-completion": "llamacpp-completion";
+                "whispercpp-transcription": "whispercpp-transcription";
+                "llamacpp-embedding": "llamacpp-embedding";
+                "nmtcpp-translation": "nmtcpp-translation";
+                "onnx-tts": "onnx-tts";
+                "parakeet-transcription": "parakeet-transcription";
+                "onnx-ocr": "onnx-ocr";
+                llm: "llm";
+                whisper: "whisper";
+                embeddings: "embeddings";
+                nmt: "nmt";
+                parakeet: "parakeet";
+                tts: "tts";
+                ocr: "ocr";
+            }>, import("zod").ZodLiteral<"vad">]>>;
+        }, import("zod/v4/core").$strip>]>>;
+    }, import("zod/v4/core").$strip>;
+    resolveConfig(cfg: LlmConfigInput, ctx: ResolveContext): Promise<{
+        config: {
+            ctx_size?: number | undefined;
+            temp?: number | undefined;
+            top_p?: number | undefined;
+            top_k?: number | undefined;
+            seed?: number | undefined;
+            gpu_layers?: number | undefined;
+            lora?: string | undefined;
+            device?: string | undefined;
+            predict?: number | undefined;
+            system_prompt?: string | undefined;
+            no_mmap?: boolean | undefined;
+            verbosity?: 0 | 3 | 2 | 1 | undefined;
+            presence_penalty?: number | undefined;
+            frequency_penalty?: number | undefined;
+            repeat_penalty?: number | undefined;
+            stop_sequences?: string[] | undefined;
+            n_discarded?: number | undefined;
+            tools?: boolean | undefined;
+        };
+        artifacts?: never;
+    } | {
+        config: {
+            ctx_size?: number | undefined;
+            temp?: number | undefined;
+            top_p?: number | undefined;
+            top_k?: number | undefined;
+            seed?: number | undefined;
+            gpu_layers?: number | undefined;
+            lora?: string | undefined;
+            device?: string | undefined;
+            predict?: number | undefined;
+            system_prompt?: string | undefined;
+            no_mmap?: boolean | undefined;
+            verbosity?: 0 | 3 | 2 | 1 | undefined;
+            presence_penalty?: number | undefined;
+            frequency_penalty?: number | undefined;
+            repeat_penalty?: number | undefined;
+            stop_sequences?: string[] | undefined;
+            n_discarded?: number | undefined;
+            tools?: boolean | undefined;
+        };
+        artifacts: {
+            projectionModelPath: string;
+        };
+    }>;
     createModel(params: CreateModelParams): PluginModelResult;
     handlers: {
         completionStream: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
@@ -37,6 +132,16 @@ export declare const llmPlugin: {
             }, import("zod/v4/core").$strip>>>;
             stream: import("zod").ZodBoolean;
             kvCache: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodBoolean, import("zod").ZodString]>>;
+            generationParams: import("zod").ZodOptional<import("zod").ZodObject<{
+                temp: import("zod").ZodOptional<import("zod").ZodNumber>;
+                top_p: import("zod").ZodOptional<import("zod").ZodNumber>;
+                top_k: import("zod").ZodOptional<import("zod").ZodNumber>;
+                predict: import("zod").ZodOptional<import("zod").ZodNumber>;
+                seed: import("zod").ZodOptional<import("zod").ZodNumber>;
+                frequency_penalty: import("zod").ZodOptional<import("zod").ZodNumber>;
+                presence_penalty: import("zod").ZodOptional<import("zod").ZodNumber>;
+                repeat_penalty: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strict>>;
             type: import("zod").ZodLiteral<"completionStream">;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             type: import("zod").ZodLiteral<"completionStream">;
@@ -109,7 +214,7 @@ export declare const llmPlugin: {
     };
     logging: {
         module: import("@qvac/llm-llamacpp/addonLogging").AddonLogging;
-        namespace: "llamacpp:llm";
+        namespace: "llamacpp-completion";
     };
 };
 //# sourceMappingURL=plugin.d.ts.map

package/dist/server/bare/plugins/llamacpp-completion/plugin.js

@@ -1,7 +1,7 @@
 import LlmLlamacpp, {} from "@qvac/llm-llamacpp";
 import llmAddonLogging from "@qvac/llm-llamacpp/addonLogging.js";
-import { definePlugin, defineHandler, completionStreamRequestSchema, completionStreamResponseSchema, translateRequestSchema, translateResponseSchema, ModelType, } from "../../../../schemas/index.js";
-import { ADDON_NAMESPACES, createStreamLogger, registerAddonLogger, } from "../../../../logging/index.js";
+import { definePlugin, defineHandler, completionStreamRequestSchema, completionStreamResponseSchema, translateRequestSchema, translateResponseSchema, ModelType, llmConfigBaseSchema, ADDON_LLM, } from "../../../../schemas/index.js";
+import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
 import { parseModelPath } from "../../../utils/index.js";
 import FilesystemDL from "@qvac/dl-filesystem";
 import { asLoader } from "../../utils/loader-adapter.js";
@@ -26,8 +26,8 @@ function transformLlmConfig(llmConfig) {
 function createLlmModel(modelId, modelPath, llmConfig, projectionModelPath) {
     const { dirPath, basePath } = parseModelPath(modelPath);
     const loader = new FilesystemDL({ dirPath });
-    const logger = createStreamLogger(modelId, ADDON_NAMESPACES.LLAMACPP_LLM);
-    registerAddonLogger(modelId, ADDON_NAMESPACES.LLAMACPP_LLM, logger);
+    const logger = createStreamLogger(modelId, ModelType.llamacppCompletion);
+    registerAddonLogger(modelId, ModelType.llamacppCompletion, logger);
     const llmConfigStrings = transformLlmConfig(llmConfig);
     const args = {
         loader: asLoader(loader),
@@ -47,7 +47,19 @@ function createLlmModel(modelId, modelPath, llmConfig, projectionModelPath) {
 export const llmPlugin = definePlugin({
     modelType: ModelType.llamacppCompletion,
     displayName: "LLM (llama.cpp)",
-    addonPackage: "@qvac/llm-llamacpp",
+    addonPackage: ADDON_LLM,
+    loadConfigSchema: llmConfigBaseSchema,
+    async resolveConfig(cfg, ctx) {
+        const { projectionModelSrc, ...llmConfig } = cfg;
+        if (!projectionModelSrc) {
+            return { config: llmConfig };
+        }
+        const projectionModelPath = await ctx.resolveModelPath(projectionModelSrc);
+        return {
+            config: llmConfig,
+            artifacts: { projectionModelPath },
+        };
+    },
     createModel(params) {
         const llmConfig = (params.modelConfig ?? {});
         const { model, loader } = createLlmModel(params.modelId, params.modelPath, llmConfig, params.artifacts?.["projectionModelPath"]);
@@ -69,6 +81,7 @@ export const llmPlugin = definePlugin({
                     modelId: request.modelId,
                     kvCache: request.kvCache,
                     ...(request.tools && { tools: request.tools }),
+                    ...(request.generationParams && { generationParams: request.generationParams }),
                 });
                 let stats;
                 let toolCalls = [];
@@ -137,6 +150,6 @@ export const llmPlugin = definePlugin({
     },
     logging: {
         module: llmAddonLogging,
-        namespace: ADDON_NAMESPACES.LLAMACPP_LLM,
+        namespace: ModelType.llamacppCompletion,
     },
 });

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

@@ -2,7 +2,37 @@ import { type CreateModelParams, type PluginModelResult } from "../../../../sche
 export declare const embeddingsPlugin: {
     modelType: "llamacpp-embedding";
     displayName: string;
-    addonPackage: string;
+    addonPackage: "@qvac/embed-llamacpp";
+    loadConfigSchema: import("zod").ZodObject<{
+        gpuLayers: import("zod").ZodOptional<import("zod").ZodNumber>;
+        device: import("zod").ZodOptional<import("zod").ZodEnum<{
+            gpu: "gpu";
+            cpu: "cpu";
+        }>>;
+        batchSize: import("zod").ZodOptional<import("zod").ZodNumber>;
+        pooling: import("zod").ZodOptional<import("zod").ZodEnum<{
+            none: "none";
+            mean: "mean";
+            cls: "cls";
+            last: "last";
+            rank: "rank";
+        }>>;
+        attention: import("zod").ZodOptional<import("zod").ZodEnum<{
+            causal: "causal";
+            "non-causal": "non-causal";
+        }>>;
+        embdNormalize: import("zod").ZodOptional<import("zod").ZodNumber>;
+        flashAttention: import("zod").ZodOptional<import("zod").ZodEnum<{
+            on: "on";
+            off: "off";
+            auto: "auto";
+        }>>;
+        mainGpu: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodEnum<{
+            integrated: "integrated";
+            dedicated: "dedicated";
+        }>]>>;
+        verbosity: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<0>, import("zod").ZodLiteral<1>, import("zod").ZodLiteral<2>, import("zod").ZodLiteral<3>]>>;
+    }, import("zod/v4/core").$strip>;
     createModel(params: CreateModelParams): PluginModelResult;
     handlers: {
         embed: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
@@ -18,7 +48,7 @@ export declare const embeddingsPlugin: {
     };
     logging: {
         module: import("@qvac/embed-llamacpp/addonLogging").AddonLogging;
-        namespace: "llamacpp:embed";
+        namespace: "llamacpp-embedding";
     };
 };
 //# sourceMappingURL=plugin.d.ts.map

package/dist/server/bare/plugins/llamacpp-embedding/plugin.js

@@ -1,32 +1,45 @@
 import EmbedLlamacpp, {} from "@qvac/embed-llamacpp";
 import embedAddonLogging from "@qvac/embed-llamacpp/addonLogging.js";
-import { definePlugin, defineHandler, embedRequestSchema, embedResponseSchema, ModelType, } from "../../../../schemas/index.js";
-import { ADDON_NAMESPACES, createStreamLogger, registerAddonLogger, } from "../../../../logging/index.js";
+import { definePlugin, defineHandler, embedRequestSchema, embedResponseSchema, ModelType, embedConfigBaseSchema, ADDON_EMBEDDING, } from "../../../../schemas/index.js";
+import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
 import { parseModelPath } from "../../../utils/index.js";
 import FilesystemDL from "@qvac/dl-filesystem";
 import { asLoader } from "../../utils/loader-adapter.js";
 import { embed } from "../../ops/embed.js";
 function transformEmbedConfig(embedConfig) {
-    if (embedConfig.rawConfig) {
-        return embedConfig.rawConfig;
+    const config = {
+        device: embedConfig.device,
+        gpu_layers: `${embedConfig.gpuLayers}`,
+        batch_size: `${embedConfig.batchSize}`,
+    };
+    if (embedConfig.flashAttention) {
+        config.flash_attn = embedConfig.flashAttention;
     }
-    const lines = [];
-    lines.push(`-ngl\t${embedConfig.gpuLayers}`);
-    lines.push(`-dev\t${embedConfig.device}`);
-    lines.push(`--batch_size\t${embedConfig.batchSize}`);
-    if (embedConfig.ctxSize) {
-        lines.push(`-c\t${embedConfig.ctxSize}`);
+    if (embedConfig.pooling) {
+        config.pooling = embedConfig.pooling;
     }
-    if (embedConfig.flashAttention) {
-        lines.push(`-fa\t${embedConfig.flashAttention}`);
+    if (embedConfig.attention) {
+        config.attention = embedConfig.attention;
+    }
+    if (typeof embedConfig.embdNormalize === "number") {
+        config.embd_normalize = `${embedConfig.embdNormalize}`;
+    }
+    if (embedConfig.mainGpu !== undefined) {
+        config["main-gpu"] =
+            typeof embedConfig.mainGpu === "number"
+                ? `${embedConfig.mainGpu}`
+                : embedConfig.mainGpu;
+    }
+    if (typeof embedConfig.verbosity === "number") {
+        config.verbosity = `${embedConfig.verbosity}`;
     }
-    return lines.join("\n");
+    return config;
 }
 function createEmbeddingsModel(modelId, modelPath, embedConfig) {
     const { dirPath, basePath } = parseModelPath(modelPath);
     const loader = new FilesystemDL({ dirPath });
-    const logger = createStreamLogger(modelId, ADDON_NAMESPACES.LLAMACPP_EMBED);
-    registerAddonLogger(modelId, ADDON_NAMESPACES.LLAMACPP_EMBED, logger);
+    const logger = createStreamLogger(modelId, ModelType.llamacppEmbedding);
+    registerAddonLogger(modelId, ModelType.llamacppEmbedding, logger);
     const config = transformEmbedConfig(embedConfig);
     const args = {
         loader: asLoader(loader),
@@ -42,7 +55,8 @@ function createEmbeddingsModel(modelId, modelPath, embedConfig) {
 export const embeddingsPlugin = definePlugin({
     modelType: ModelType.llamacppEmbedding,
     displayName: "Embeddings (llama.cpp)",
-    addonPackage: "@qvac/embed-llamacpp",
+    addonPackage: ADDON_EMBEDDING,
+    loadConfigSchema: embedConfigBaseSchema,
     createModel(params) {
         const embedConfig = (params.modelConfig ?? {});
         const { model, loader } = createEmbeddingsModel(params.modelId, params.modelPath, embedConfig);
@@ -68,6 +82,6 @@ export const embeddingsPlugin = definePlugin({
     },
     logging: {
         module: embedAddonLogging,
-        namespace: ADDON_NAMESPACES.LLAMACPP_EMBED,
+        namespace: ModelType.llamacppEmbedding,
     },
 });