@qvac/sdk 0.8.1 → 1.0.0

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

@@ -1,85 +0,0 @@
-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 { 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, 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 {};
-    }
-    // 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);
-        const isValid = await validateShardedModelCache(shardDir, modelFileName);
-        if (!isValid) {
-            const numberedShards = generateShardFilenames(modelFileName);
-            throw new ModelFileNotFoundError(`Missing shards or ${shardInfo.baseFilename}.tensors.txt. Expected ${numberedShards.length} shard files + tensors.txt in ${shardDir}`);
-        }
-    }
-    else if (!plugin.skipPrimaryModelPathValidation) {
-        // For non-sharded models, validate single file exists
-        try {
-            const modelDir = path.dirname(modelPath);
-            const modelFile = path.basename(modelPath);
-            const files = (await fsPromises.readdir(modelDir));
-            if (!files.includes(modelFile)) {
-                throw new ModelFileNotFoundInDirError(modelFile, modelDir, modelType);
-            }
-        }
-        catch (error) {
-            logger.error(`Error reading ${modelType} model directory:`, error instanceof Error ? error.message : String(error));
-            throw new ModelFileLocateFailedError(modelType, modelPath, error);
-        }
-    }
-    logger.info(`${modelType}: Loading model ${modelId}...`);
-    startLogBuffering(modelId);
-    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

@@ -1,3 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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,5 +0,0 @@
-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/unload-model.js

@@ -1,41 +0,0 @@
-import { promises as fsPromises } from "bare-fs";
-import path from "bare-path";
-import { unregisterModel } from "../registry/model-registry.js";
-import { unregisterAllLoggingStreams } from "../registry/logging-stream-registry.js";
-import { unregisterAddonLogger, getServerLogger } from "../../../logging/index.js";
-import { unloadModelParamsSchema } from "../../../schemas/index.js";
-import { ModelNotLoadedError } from "../../../utils/errors-server.js";
-import { detectShardedModel } from "../../utils/index.js";
-const logger = getServerLogger();
-export async function unloadModel(params) {
-    const { modelId, clearStorage } = unloadModelParamsSchema.parse(params);
-    const entry = unregisterModel(modelId);
-    if (!entry) {
-        throw new ModelNotLoadedError(modelId);
-    }
-    if (entry.local?.loader) {
-        await entry.local.loader.close();
-    }
-    if (entry.local?.model && entry.local.model.unload) {
-        await entry.local.model.unload();
-    }
-    if (clearStorage && entry.local?.path) {
-        const modelPath = entry.local.path;
-        const modelFileName = path.basename(modelPath);
-        const shardInfo = detectShardedModel(modelFileName);
-        if (shardInfo.isSharded) {
-            // Delete entire shard directory
-            const shardDir = path.dirname(modelPath);
-            await fsPromises.rm(shardDir, { recursive: true, force: true });
-            logger.info(`Sharded model storage cleared: ${shardDir}`);
-        }
-        else {
-            // Delete single file
-            await fsPromises.rm(modelPath, { recursive: true, force: true });
-            logger.info(`Model storage cleared: ${modelPath}`);
-        }
-    }
-    unregisterAddonLogger(modelId);
-    unregisterAllLoggingStreams(modelId);
-    logger.info(`Model ${modelId} unloaded`);
-}

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

@@ -1,8 +0,0 @@
-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";
-//# sourceMappingURL=index.d.ts.map

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

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

@@ -1,6 +0,0 @@
-export declare function logCacheStatus(cacheKey: string, isReusing: boolean): void;
-export declare function logCacheInit(cacheKey: string, systemPrompt: string, toolCount: number): void;
-export declare function logMessagesToAddon(messages: unknown[], phase?: "CACHE_INIT" | "PROMPT_SEND" | "NO_CACHE"): void;
-export declare function logCacheDisabled(): void;
-export declare function logCacheSave(sessionPath: string): void;
-//# sourceMappingURL=cache-logger.d.ts.map

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

@@ -1,34 +0,0 @@
-import { getServerLogger } from "../../../../../logging/index.js";
-const logger = getServerLogger();
-function formatMessages(messages) {
-    return messages
-        .map((m) => {
-        const role = m.role || m.type || "?";
-        const content = m.content
-            ? m.content.length > 40
-                ? m.content.substring(0, 40) + "..."
-                : m.content
-            : m.name || "(no content)";
-        return `{${role}: "${content}"}`;
-    })
-        .join(", ");
-}
-export function logCacheStatus(cacheKey, isReusing) {
-    const status = isReusing ? "REUSING" : "CREATING";
-    logger.debug(`[kv-cache] [${cacheKey}] ${status} cache`);
-}
-export function logCacheInit(cacheKey, systemPrompt, toolCount) {
-    const promptLen = systemPrompt.length;
-    logger.debug(`[kv-cache] [${cacheKey}] Initializing cache (prompt: ${promptLen} chars, tools: ${toolCount})`);
-}
-export function logMessagesToAddon(messages, phase = "PROMPT_SEND") {
-    const typedMessages = messages;
-    const nonSessionMsgs = typedMessages.filter((m) => m.role !== "session");
-    logger.debug(`[kv-cache] [${phase}] Sending ${nonSessionMsgs.length} msg(s): [${formatMessages(nonSessionMsgs)}]`);
-}
-export function logCacheDisabled() {
-    logger.debug("[kv-cache] Cache disabled");
-}
-export function logCacheSave(sessionPath) {
-    logger.debug(`[kv-cache] Saving session: ...${sessionPath.slice(-20)}`);
-}

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

@@ -1,220 +0,0 @@
-import { type CreateModelParams, type PluginModelResult, type ResolveContext, type LlmConfigInput } from "../../../../schemas/index";
-export declare const llmPlugin: {
-    modelType: "llamacpp-completion";
-    displayName: 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<{
-            history: import("zod").ZodArray<import("zod").ZodObject<{
-                role: import("zod").ZodString;
-                content: import("zod").ZodString;
-                attachments: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-                    path: import("zod").ZodString;
-                }, import("zod/v4/core").$strip>>>;
-            }, import("zod/v4/core").$strip>>;
-            modelId: import("zod").ZodString;
-            tools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-                type: import("zod").ZodLiteral<"function">;
-                name: import("zod").ZodString;
-                description: import("zod").ZodString;
-                parameters: import("zod").ZodObject<{
-                    type: import("zod").ZodLiteral<"object">;
-                    properties: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
-                        type: import("zod").ZodEnum<{
-                            string: "string";
-                            number: "number";
-                            boolean: "boolean";
-                            object: "object";
-                            array: "array";
-                            integer: "integer";
-                        }>;
-                        description: import("zod").ZodOptional<import("zod").ZodString>;
-                        enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-                    }, import("zod/v4/core").$strip>>;
-                    required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-                }, import("zod/v4/core").$strip>;
-            }, 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">;
-            token: import("zod").ZodString;
-            done: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            stats: import("zod").ZodOptional<import("zod").ZodObject<{
-                timeToFirstToken: import("zod").ZodNumber;
-                tokensPerSecond: import("zod").ZodNumber;
-                cacheTokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>>;
-            toolCallEvent: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
-                type: import("zod").ZodLiteral<"toolCall">;
-                call: import("zod").ZodObject<{
-                    id: import("zod").ZodString;
-                    name: import("zod").ZodString;
-                    arguments: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
-                    raw: import("zod").ZodOptional<import("zod").ZodString>;
-                }, import("zod/v4/core").$strip>;
-            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-                type: import("zod").ZodLiteral<"toolCallError">;
-                error: import("zod").ZodObject<{
-                    code: import("zod").ZodEnum<{
-                        PARSE_ERROR: "PARSE_ERROR";
-                        VALIDATION_ERROR: "VALIDATION_ERROR";
-                        UNKNOWN_TOOL: "UNKNOWN_TOOL";
-                    }>;
-                    message: import("zod").ZodString;
-                    raw: import("zod").ZodOptional<import("zod").ZodString>;
-                }, import("zod/v4/core").$strip>;
-            }, import("zod/v4/core").$strip>]>>;
-            toolCalls: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                name: import("zod").ZodString;
-                arguments: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
-                raw: import("zod").ZodOptional<import("zod").ZodString>;
-            }, import("zod/v4/core").$strip>>>;
-            error: import("zod").ZodOptional<import("zod").ZodString>;
-        }, import("zod/v4/core").$strip>>;
-        translate: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
-            modelId: import("zod").ZodString;
-            text: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>;
-            stream: import("zod").ZodBoolean;
-            modelType: import("zod").ZodEnum<{
-                "nmtcpp-translation": "nmtcpp-translation";
-                nmt: "nmt";
-            }>;
-            type: import("zod").ZodLiteral<"translate">;
-        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-            modelId: import("zod").ZodString;
-            text: import("zod").ZodString;
-            stream: import("zod").ZodBoolean;
-            modelType: import("zod").ZodEnum<{
-                "llamacpp-completion": "llamacpp-completion";
-                llm: "llm";
-            }>;
-            from: import("zod").ZodOptional<import("zod").ZodString>;
-            to: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            type: import("zod").ZodLiteral<"translate">;
-        }, import("zod/v4/core").$strip>]>, import("zod").ZodObject<{
-            type: import("zod").ZodLiteral<"translate">;
-            token: import("zod").ZodString;
-            done: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            stats: import("zod").ZodOptional<import("zod").ZodObject<{
-                processedTokens: import("zod").ZodNumber;
-                processingTime: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>>;
-            error: import("zod").ZodOptional<import("zod").ZodString>;
-        }, import("zod/v4/core").$strip>>;
-    };
-    logging: {
-        module: import("@qvac/llm-llamacpp/addonLogging").AddonLogging;
-        namespace: "llamacpp-completion";
-    };
-};
-//# sourceMappingURL=plugin.d.ts.map

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

@@ -1,155 +0,0 @@
-import LlmLlamacpp, {} from "@qvac/llm-llamacpp";
-import llmAddonLogging from "@qvac/llm-llamacpp/addonLogging.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";
-import { completion } from "./ops/completion-stream.js";
-import { translate } from "../../ops/translate.js";
-function transformLlmConfig(llmConfig) {
-    const transformed = JSON.parse(JSON.stringify(llmConfig, (key, v) => key === "modelType"
-        ? undefined
-        : key === "stop_sequences"
-            ? Array.isArray(v)
-                ? v.join(", ")
-                : v
-            : typeof v === "number" || typeof v === "boolean"
-                ? String(v)
-                : v).replace(/"([a-z][A-Za-z]*)":/g, (_, key) => `"${key.replace(/[A-Z]/g, (l) => `_${l.toLowerCase()}`)}":`));
-    if ("stop_sequences" in transformed) {
-        transformed["reverse_prompt"] = transformed["stop_sequences"];
-        delete transformed["stop_sequences"];
-    }
-    return transformed;
-}
-function createLlmModel(modelId, modelPath, llmConfig, projectionModelPath) {
-    const { dirPath, basePath } = parseModelPath(modelPath);
-    const loader = new FilesystemDL({ dirPath });
-    const logger = createStreamLogger(modelId, ModelType.llamacppCompletion);
-    registerAddonLogger(modelId, ModelType.llamacppCompletion, logger);
-    const llmConfigStrings = transformLlmConfig(llmConfig);
-    const args = {
-        loader: asLoader(loader),
-        opts: { stats: true },
-        logger,
-        diskPath: dirPath,
-        modelName: basePath,
-        projectionModel: projectionModelPath
-            ? parseModelPath(projectionModelPath).basePath
-            : "",
-        modelPath,
-        modelConfig: llmConfigStrings,
-    };
-    const model = new LlmLlamacpp(args, llmConfigStrings);
-    return { model, loader };
-}
-export const llmPlugin = definePlugin({
-    modelType: ModelType.llamacppCompletion,
-    displayName: "LLM (llama.cpp)",
-    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"]);
-        return { model, loader };
-    },
-    handlers: {
-        completionStream: defineHandler({
-            requestSchema: completionStreamRequestSchema,
-            responseSchema: completionStreamResponseSchema,
-            streaming: true,
-            handler: async function* (request) {
-                const filteredHistory = request.history.map(({ role, content, attachments }) => ({
-                    role,
-                    content,
-                    attachments: attachments ?? [],
-                }));
-                const stream = completion({
-                    history: filteredHistory,
-                    modelId: request.modelId,
-                    kvCache: request.kvCache,
-                    ...(request.tools && { tools: request.tools }),
-                    ...(request.generationParams && { generationParams: request.generationParams }),
-                });
-                let stats;
-                let toolCalls = [];
-                let done = false;
-                let buffer = "";
-                while (!done) {
-                    const result = await stream.next();
-                    if (result.done) {
-                        stats = result.value.stats;
-                        toolCalls = result.value.toolCalls;
-                        done = true;
-                    }
-                    else {
-                        if (request.stream) {
-                            yield {
-                                type: "completionStream",
-                                token: result.value.token,
-                                ...(result.value.toolCallEvent && {
-                                    toolCallEvent: result.value.toolCallEvent,
-                                }),
-                            };
-                        }
-                        else {
-                            buffer += result.value.token;
-                        }
-                    }
-                }
-                yield {
-                    type: "completionStream",
-                    token: request.stream ? "" : buffer,
-                    done: true,
-                    ...(stats && { stats }),
-                    ...(toolCalls.length > 0 && { toolCalls }),
-                };
-            },
-        }),
-        translate: defineHandler({
-            requestSchema: translateRequestSchema,
-            responseSchema: translateResponseSchema,
-            streaming: true,
-            handler: async function* (request) {
-                const stream = translate(request);
-                let done = false;
-                let stats;
-                while (!done) {
-                    const result = await stream.next();
-                    if (result.done) {
-                        stats = result.value;
-                        done = true;
-                    }
-                    else {
-                        yield {
-                            type: "translate",
-                            token: result.value,
-                        };
-                    }
-                }
-                yield {
-                    type: "translate",
-                    token: "",
-                    done: true,
-                    ...(stats && { stats }),
-                };
-            },
-        }),
-    },
-    logging: {
-        module: llmAddonLogging,
-        namespace: ModelType.llamacppCompletion,
-    },
-});