@qvac/sdk 0.7.1 → 0.8.1

package/dist/server/bare/delegate-rpc-client.js

@@ -3,6 +3,8 @@ import RPC from "bare-rpc";
 import { withTimeout } from "../../utils/withTimeout.js";
 import { DelegateConnectionFailedError } from "../../utils/errors-server.js";
 import { getServerLogger } from "../../logging/index.js";
+import { nowMs } from "../../profiling/index.js";
+import { cacheDelegationConnectionTime, clearPeerConnectionTracking, } from "../rpc/profiling/delegation-profiler.js";
 const logger = getServerLogger();
 // Map of active RPC instances by public key
 const activeRPCs = new Map();
@@ -10,6 +12,26 @@ const activeRPCs = new Map();
 const activeConnections = new Map();
 // Track whether the global connection handler has been registered
 let connectionHandlerRegistered = false;
+const HEALTH_CHECK_TIMEOUT_MS = 1500;
+import { getNextCommandId } from "../rpc/delegate-utils.js";
+function isHeartbeatResponse(payload) {
+    return (typeof payload === "object" &&
+        payload !== null &&
+        payload["type"] === "heartbeat");
+}
+async function isRPCConnectionHealthy(rpc, timeout = HEALTH_CHECK_TIMEOUT_MS) {
+    try {
+        const req = rpc.request(getNextCommandId());
+        req.send(JSON.stringify({ type: "heartbeat" }), "utf-8");
+        const response = await withTimeout(req.reply("utf-8"), timeout);
+        const payload = JSON.parse(response?.toString() || "{}");
+        return isHeartbeatResponse(payload);
+    }
+    catch (error) {
+        logger.debug("RPC health check failed", { error });
+        return false;
+    }
+}
 /**
  * Register the swarm "connection" handler once (not per getRPC call).
  * This fixes the event listener leak where each getRPC() call added
@@ -36,11 +58,13 @@ function ensureConnectionHandler() {
             logger.debug(`Connection closed for peer: ${peerPubkey}`);
             activeRPCs.delete(peerPubkey);
             activeConnections.delete(peerPubkey);
+            clearPeerConnectionTracking(peerPubkey);
         });
         conn.on("error", (err) => {
             logger.error(`Connection error for peer ${peerPubkey}:`, err);
             activeRPCs.delete(peerPubkey);
             activeConnections.delete(peerPubkey);
+            clearPeerConnectionTracking(peerPubkey);
         });
     });
 }
@@ -60,16 +84,35 @@ async function closeConnection(publicKey) {
         });
         activeConnections.delete(publicKey);
         activeRPCs.delete(publicKey);
+        clearPeerConnectionTracking(publicKey);
     }
 }
 // Establish RPC connection to a peer if not already connected
-async function ensureRPCConnection(topic, publicKey, timeout) {
+async function ensureRPCConnection(topic, publicKey, timeout, healthCheckTimeout) {
+    const healthCheckCap = healthCheckTimeout ?? HEALTH_CHECK_TIMEOUT_MS;
+    const operationStart = nowMs();
+    const getRemainingTimeout = () => {
+        if (timeout === undefined) {
+            return undefined;
+        }
+        return Math.max(timeout - (nowMs() - operationStart), 0);
+    };
     // Check if we already have an RPC instance for this peer
     const existingRpc = activeRPCs.get(publicKey);
     if (existingRpc) {
-        return existingRpc;
+        const remainingTimeout = getRemainingTimeout();
+        const probeTimeout = remainingTimeout === undefined
+            ? healthCheckCap
+            : Math.min(remainingTimeout / 2, healthCheckCap);
+        const isHealthy = await isRPCConnectionHealthy(existingRpc, probeTimeout);
+        if (isHealthy) {
+            return existingRpc;
+        }
+        logger.info(`🧹 Cached RPC failed health check for peer ${publicKey}, reconnecting`);
+        cleanupStaleConnection(publicKey);
     }
     const swarm = getSwarm();
+    const connectionStart = nowMs();
     // Track the listener so we can clean it up on timeout
     let onConnection = () => { };
     try {
@@ -126,20 +169,17 @@ async function ensureRPCConnection(topic, publicKey, timeout) {
                 logger.debug(`⏳ Peer not connected after flush, waiting for connection event...`);
             });
         });
-        return await withTimeout(connectionPromise, timeout);
+        const rpc = await withTimeout(connectionPromise, getRemainingTimeout());
+        const connectionDuration = nowMs() - connectionStart;
+        cacheDelegationConnectionTime(publicKey, connectionDuration);
+        return rpc;
     }
     catch (error) {
         // Clean up the per-request connection listener
         swarm.removeListener("connection", onConnection);
         // Remove stale connection so next attempt creates a fresh one
         // instead of reusing a dead RPC
-        logger.info(`🗑️ Removing stale connection for peer: ${publicKey} after failed RPC attempt`);
-        activeRPCs.delete(publicKey);
-        const conn = activeConnections.get(publicKey);
-        if (conn) {
-            conn.destroy();
-            activeConnections.delete(publicKey);
-        }
+        cleanupStaleConnection(publicKey);
         logger.error("Failed to establish RPC connection:", error);
         throw new DelegateConnectionFailedError(`RPC connection failed: ${error instanceof Error ? error.message : String(error)}`, error);
     }
@@ -153,7 +193,7 @@ export async function getRPC(topic, publicKey, options = {}) {
     if (options.forceNewConnection) {
         await closeConnection(publicKey);
     }
-    return await ensureRPCConnection(topic, publicKey, options.timeout);
+    return await ensureRPCConnection(topic, publicKey, options.timeout, options.healthCheckTimeout);
 }
 /**
  * Remove a stale RPC connection for a peer.
@@ -168,4 +208,5 @@ export function cleanupStaleConnection(publicKey) {
         conn.destroy();
         activeConnections.delete(publicKey);
     }
+    clearPeerConnectionTracking(publicKey);
 }

package/dist/server/bare/ops/load-model.d.ts

@@ -1,3 +1,9 @@
 import { type LoadModelServerParams } from "../../../schemas/index";
-export declare function loadModel(params: LoadModelServerParams): Promise<void>;
+import type { LoadTimingStats } from "../../../profiling/types";
+export interface LoadModelResult {
+    timing?: LoadTimingStats;
+}
+export declare function loadModel(params: LoadModelServerParams, options?: {
+    collectTiming?: boolean;
+}): Promise<LoadModelResult>;
 //# sourceMappingURL=load-model.d.ts.map

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,
     },
 });