@qvac/sdk 0.1.0-dev.1760648187.328e967

package/dist/schemas/translation-config.d.ts

@@ -0,0 +1,83 @@
+import { z } from "zod";
+export declare const INDICTRANS_LANGUAGES: readonly ["asm_Beng", "ben_Beng", "brx_Deva", "doi_Deva", "eng_Latn", "gom_Deva", "guj_Gujr", "hin_Deva", "kan_Knda", "kas_Arab", "kas_Deva", "mai_Deva", "mal_Mlym", "mar_Deva", "mni_Beng", "mni_Mtei", "npi_Deva", "ory_Orya", "pan_Guru", "san_Deva", "sat_Olck", "snd_Arab", "snd_Deva", "tam_Taml", "tel_Telu", "urd_Arab"];
+export declare const NMT_LANGUAGES: readonly ["en", "de", "es", "it", "asm_Beng", "ben_Beng", "brx_Deva", "doi_Deva", "eng_Latn", "gom_Deva", "guj_Gujr", "hin_Deva", "kan_Knda", "kas_Arab", "kas_Deva", "mai_Deva", "mal_Mlym", "mar_Deva", "mni_Beng", "mni_Mtei", "npi_Deva", "ory_Orya", "pan_Guru", "san_Deva", "sat_Olck", "snd_Arab", "snd_Deva", "tam_Taml", "tel_Telu", "urd_Arab"];
+export declare const nmtConfigSchema: z.ZodPipe<z.ZodObject<{
+    mode: z.ZodOptional<z.ZodEnum<{
+        full: "full";
+    }>>;
+    from: z.ZodEnum<{
+        en: "en";
+        de: "de";
+        es: "es";
+        it: "it";
+        asm_Beng: "asm_Beng";
+        ben_Beng: "ben_Beng";
+        brx_Deva: "brx_Deva";
+        doi_Deva: "doi_Deva";
+        eng_Latn: "eng_Latn";
+        gom_Deva: "gom_Deva";
+        guj_Gujr: "guj_Gujr";
+        hin_Deva: "hin_Deva";
+        kan_Knda: "kan_Knda";
+        kas_Arab: "kas_Arab";
+        kas_Deva: "kas_Deva";
+        mai_Deva: "mai_Deva";
+        mal_Mlym: "mal_Mlym";
+        mar_Deva: "mar_Deva";
+        mni_Beng: "mni_Beng";
+        mni_Mtei: "mni_Mtei";
+        npi_Deva: "npi_Deva";
+        ory_Orya: "ory_Orya";
+        pan_Guru: "pan_Guru";
+        san_Deva: "san_Deva";
+        sat_Olck: "sat_Olck";
+        snd_Arab: "snd_Arab";
+        snd_Deva: "snd_Deva";
+        tam_Taml: "tam_Taml";
+        tel_Telu: "tel_Telu";
+        urd_Arab: "urd_Arab";
+    }>;
+    to: z.ZodEnum<{
+        en: "en";
+        de: "de";
+        es: "es";
+        it: "it";
+        asm_Beng: "asm_Beng";
+        ben_Beng: "ben_Beng";
+        brx_Deva: "brx_Deva";
+        doi_Deva: "doi_Deva";
+        eng_Latn: "eng_Latn";
+        gom_Deva: "gom_Deva";
+        guj_Gujr: "guj_Gujr";
+        hin_Deva: "hin_Deva";
+        kan_Knda: "kan_Knda";
+        kas_Arab: "kas_Arab";
+        kas_Deva: "kas_Deva";
+        mai_Deva: "mai_Deva";
+        mal_Mlym: "mal_Mlym";
+        mar_Deva: "mar_Deva";
+        mni_Beng: "mni_Beng";
+        mni_Mtei: "mni_Mtei";
+        npi_Deva: "npi_Deva";
+        ory_Orya: "ory_Orya";
+        pan_Guru: "pan_Guru";
+        san_Deva: "san_Deva";
+        sat_Olck: "sat_Olck";
+        snd_Arab: "snd_Arab";
+        snd_Deva: "snd_Deva";
+        tam_Taml: "tam_Taml";
+        tel_Telu: "tel_Telu";
+        urd_Arab: "urd_Arab";
+    }>;
+}, z.core.$strip>, z.ZodTransform<{
+    mode: "full";
+    from: "en" | "de" | "es" | "it" | "asm_Beng" | "ben_Beng" | "brx_Deva" | "doi_Deva" | "eng_Latn" | "gom_Deva" | "guj_Gujr" | "hin_Deva" | "kan_Knda" | "kas_Arab" | "kas_Deva" | "mai_Deva" | "mal_Mlym" | "mar_Deva" | "mni_Beng" | "mni_Mtei" | "npi_Deva" | "ory_Orya" | "pan_Guru" | "san_Deva" | "sat_Olck" | "snd_Arab" | "snd_Deva" | "tam_Taml" | "tel_Telu" | "urd_Arab";
+    to: "en" | "de" | "es" | "it" | "asm_Beng" | "ben_Beng" | "brx_Deva" | "doi_Deva" | "eng_Latn" | "gom_Deva" | "guj_Gujr" | "hin_Deva" | "kan_Knda" | "kas_Arab" | "kas_Deva" | "mai_Deva" | "mal_Mlym" | "mar_Deva" | "mni_Beng" | "mni_Mtei" | "npi_Deva" | "ory_Orya" | "pan_Guru" | "san_Deva" | "sat_Olck" | "snd_Arab" | "snd_Deva" | "tam_Taml" | "tel_Telu" | "urd_Arab";
+}, {
+    from: "en" | "de" | "es" | "it" | "asm_Beng" | "ben_Beng" | "brx_Deva" | "doi_Deva" | "eng_Latn" | "gom_Deva" | "guj_Gujr" | "hin_Deva" | "kan_Knda" | "kas_Arab" | "kas_Deva" | "mai_Deva" | "mal_Mlym" | "mar_Deva" | "mni_Beng" | "mni_Mtei" | "npi_Deva" | "ory_Orya" | "pan_Guru" | "san_Deva" | "sat_Olck" | "snd_Arab" | "snd_Deva" | "tam_Taml" | "tel_Telu" | "urd_Arab";
+    to: "en" | "de" | "es" | "it" | "asm_Beng" | "ben_Beng" | "brx_Deva" | "doi_Deva" | "eng_Latn" | "gom_Deva" | "guj_Gujr" | "hin_Deva" | "kan_Knda" | "kas_Arab" | "kas_Deva" | "mai_Deva" | "mal_Mlym" | "mar_Deva" | "mni_Beng" | "mni_Mtei" | "npi_Deva" | "ory_Orya" | "pan_Guru" | "san_Deva" | "sat_Olck" | "snd_Arab" | "snd_Deva" | "tam_Taml" | "tel_Telu" | "urd_Arab";
+    mode?: "full" | undefined;
+}>>;
+export type NmtLanguage = (typeof NMT_LANGUAGES)[number];
+export type NmtConfig = z.infer<typeof nmtConfigSchema>;
+//# sourceMappingURL=translation-config.d.ts.map

package/dist/schemas/translation-config.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+// Marian model languages
+const MARIAN_LANGUAGES = ["en", "de", "es", "it"];
+// IndicTrans2 model languages
+export const INDICTRANS_LANGUAGES = [
+    "asm_Beng", // Assamese
+    "ben_Beng", // Bengali
+    "brx_Deva", // Bodo
+    "doi_Deva", // Dogri
+    "eng_Latn", // English
+    "gom_Deva", // Konkani
+    "guj_Gujr", // Gujarati
+    "hin_Deva", // Hindi
+    "kan_Knda", // Kannada
+    "kas_Arab", // Kashmiri (Arabic)
+    "kas_Deva", // Kashmiri (Devanagari)
+    "mai_Deva", // Maithili
+    "mal_Mlym", // Malayalam
+    "mar_Deva", // Marathi
+    "mni_Beng", // Manipuri (Bengali)
+    "mni_Mtei", // Manipuri (Meitei)
+    "npi_Deva", // Nepali
+    "ory_Orya", // Odia
+    "pan_Guru", // Punjabi
+    "san_Deva", // Sanskrit
+    "sat_Olck", // Santali
+    "snd_Arab", // Sindhi (Arabic)
+    "snd_Deva", // Sindhi (Devanagari)
+    "tam_Taml", // Tamil
+    "tel_Telu", // Telugu
+    "urd_Arab", // Urdu
+];
+export const NMT_LANGUAGES = [
+    ...MARIAN_LANGUAGES,
+    ...INDICTRANS_LANGUAGES,
+];
+export const nmtConfigSchema = z
+    .object({
+    mode: z.enum(["full"]).optional(),
+    from: z.enum(NMT_LANGUAGES),
+    to: z.enum(NMT_LANGUAGES),
+})
+    .transform((data) => ({
+    ...data,
+    mode: data.mode ?? "full",
+}));

package/dist/schemas/unload-model.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export declare const unloadModelParamsSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    clearStorage: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const unloadModelRequestSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    clearStorage: z.ZodDefault<z.ZodBoolean>;
+    type: z.ZodLiteral<"unloadModel">;
+}, z.core.$strip>;
+export declare const unloadModelResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"unloadModel">;
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type UnloadModelParams = z.input<typeof unloadModelParamsSchema>;
+export type UnloadModelRequest = z.infer<typeof unloadModelRequestSchema>;
+export type UnloadModelResponse = z.infer<typeof unloadModelResponseSchema>;
+//# sourceMappingURL=unload-model.d.ts.map

package/dist/schemas/unload-model.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export const unloadModelParamsSchema = z.object({
+    modelId: z.string(),
+    clearStorage: z.boolean().default(false),
+});
+export const unloadModelRequestSchema = unloadModelParamsSchema.extend({
+    type: z.literal("unloadModel"),
+});
+export const unloadModelResponseSchema = z.object({
+    type: z.literal("unloadModel"),
+    success: z.boolean(),
+    error: z.string().optional(),
+});

package/dist/schemas/whispercpp-config.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export declare const whisperConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        caption: "caption";
+        batch: "batch";
+    }>>;
+    output_format: z.ZodDefault<z.ZodEnum<{
+        plaintext: "plaintext";
+        json: "json";
+    }>>;
+    min_seconds: z.ZodDefault<z.ZodNumber>;
+    max_seconds: z.ZodDefault<z.ZodNumber>;
+    audio_format: z.ZodDefault<z.ZodString>;
+    update_frequency: z.ZodDefault<z.ZodString>;
+    vadConfig: z.ZodOptional<z.ZodObject<{
+        vad_threshold: z.ZodOptional<z.ZodNumber>;
+        vad_min_speech_duration_ms: z.ZodOptional<z.ZodNumber>;
+        vad_min_silence_duration_ms: z.ZodOptional<z.ZodNumber>;
+        vad_max_speech_duration_s: z.ZodOptional<z.ZodNumber>;
+        vad_speech_pad_ms: z.ZodOptional<z.ZodNumber>;
+        vad_samples_overlap: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type WhisperConfig = z.infer<typeof whisperConfigSchema>;
+//# sourceMappingURL=whispercpp-config.d.ts.map

package/dist/schemas/whispercpp-config.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+const vadConfigSchema = z.object({
+    vad_threshold: z.number().optional(),
+    vad_min_speech_duration_ms: z.number().optional(),
+    vad_min_silence_duration_ms: z.number().optional(),
+    vad_max_speech_duration_s: z.number().optional(),
+    vad_speech_pad_ms: z.number().optional(),
+    vad_samples_overlap: z.number().optional(),
+});
+export const whisperConfigSchema = z.object({
+    mode: z.enum(["caption", "batch"]).default("caption"),
+    output_format: z.enum(["plaintext", "json"]).default("plaintext"),
+    min_seconds: z.number().default(1),
+    max_seconds: z.number().default(30),
+    audio_format: z.string().default("wav"),
+    update_frequency: z.string().default("on_end"),
+    vadConfig: vadConfigSchema.optional(),
+});

package/dist/server/bare/addons/cancel.d.ts

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

package/dist/server/bare/addons/cancel.js

@@ -0,0 +1,12 @@
+import { getModel } from "../registry/model-registry.js";
+import { cancelInferenceBaseSchema, } from "../../../schemas/index.js";
+export async function cancel(params) {
+    const { modelId } = cancelInferenceBaseSchema.parse(params);
+    const model = getModel(modelId);
+    if (!model) {
+        throw new Error(`Model with ID "${modelId}" is not loaded`);
+    }
+    if (model.addon && model.addon.cancel) {
+        await model.addon.cancel();
+    }
+}

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

@@ -0,0 +1,4 @@
+export { loadModel } from "./load-model";
+export { unloadModel } from "./unload-model";
+export { cancel } from "./cancel";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,3 @@
+export { loadModel } from "./load-model.js";
+export { unloadModel } from "./unload-model.js";
+export { cancel } from "./cancel.js";

package/dist/server/bare/addons/llamacpp/create-model.d.ts

@@ -0,0 +1,5 @@
+import type { AnyModel } from "../../registry/model-registry";
+import type { EmbedConfig, LlmConfig } from "../../../../schemas/index";
+export declare function createLlmModel(modelId: string, modelPath: string, llmConfig: LlmConfig, projectionModelPath?: string): AnyModel;
+export declare function createEmbeddingsModel(modelId: string, modelPath: string, embedConfig: EmbedConfig): AnyModel;
+//# sourceMappingURL=create-model.d.ts.map

package/dist/server/bare/addons/llamacpp/create-model.js

@@ -0,0 +1,57 @@
+import LlmLlamacpp from "@qvac/llm-llamacpp";
+import EmbedLlamacpp from "@qvac/embed-llamacpp";
+import { Readable } from "bare-stream";
+import { createStreamLogger } from "../../../../logging/index.js";
+import { parseModelPath } from "../../../utils/index.js";
+// Mimic qvac-lib-dl-filesystem functionality
+function createFilesystemDLMimic() {
+    return {
+        dirPath: "./",
+        getStream: () => Promise.resolve(Readable.from([])),
+        ready: () => Promise.resolve(),
+        close: () => Promise.resolve(),
+        destroy: () => Promise.resolve(),
+        start: () => Promise.resolve(),
+        stop: () => Promise.resolve(),
+    };
+}
+function transformLlmConfig(llmConfig) {
+    return JSON.parse(JSON.stringify(llmConfig, (key, v) => key === "modelType"
+        ? undefined
+        : 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()}`)}":`));
+}
+export function createLlmModel(modelId, modelPath, llmConfig, projectionModelPath) {
+    const { dirPath, basePath } = parseModelPath(modelPath);
+    const dl = createFilesystemDLMimic();
+    const logger = createStreamLogger(modelId, "llamacpp:llm");
+    const llmConfigStrings = transformLlmConfig(llmConfig);
+    const args = {
+        loader: dl,
+        opts: { stats: true },
+        logger,
+        diskPath: dirPath,
+        modelName: basePath,
+        projectionModel: projectionModelPath
+            ? parseModelPath(projectionModelPath).basePath
+            : "",
+        modelPath,
+        modelConfig: llmConfigStrings,
+    };
+    return new LlmLlamacpp(args, llmConfigStrings);
+}
+export function createEmbeddingsModel(modelId, modelPath, embedConfig) {
+    const { dirPath, basePath } = parseModelPath(modelPath);
+    const dl = createFilesystemDLMimic();
+    const logger = createStreamLogger(modelId, "llamacpp:embed");
+    const args = {
+        loader: dl,
+        opts: { stats: true },
+        logger,
+        diskPath: dirPath,
+        modelName: basePath,
+        modelPath,
+    };
+    return new EmbedLlamacpp(args, embedConfig.config);
+}

package/dist/server/bare/addons/llamacpp/handlers/completion-stream.d.ts

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

package/dist/server/bare/addons/llamacpp/handlers/completion-stream.js

@@ -0,0 +1,65 @@
+import { completionParamsSchema, } from "../../../../../schemas/index.js";
+import { getModel } from "../../../registry/model-registry.js";
+import { findMatchingCache, getCurrentCacheInfo, renameCacheFile, } from "../kv-cache-utils";
+export async function* completion(params) {
+    const { history, modelId, kvCache } = completionParamsSchema.parse(params);
+    const transformedHistory = [];
+    for (const message of history) {
+        if (message.attachments && message.attachments.length > 0) {
+            for (const attachment of message.attachments) {
+                transformedHistory.push({
+                    role: message.role,
+                    content: attachment.path,
+                    type: "media",
+                });
+            }
+        }
+        transformedHistory.push({
+            role: message.role,
+            content: message.content,
+        });
+    }
+    const model = getModel(modelId);
+    if (kvCache) {
+        const cacheMessages = history.map((msg) => ({
+            role: msg.role,
+            content: msg.content,
+            attachments: msg.attachments ?? undefined,
+        }));
+        const existingCache = await findMatchingCache(cacheMessages);
+        const currentCacheInfo = getCurrentCacheInfo(cacheMessages);
+        const cachePathToUse = existingCache !== null
+            ? existingCache.cachePath
+            : currentCacheInfo.cachePath;
+        const messagesWithCache = [
+            { role: "session", content: cachePathToUse },
+            ...transformedHistory,
+        ];
+        const response = await model.run(messagesWithCache);
+        for await (const token of response.iterate()) {
+            yield token;
+        }
+        await model.run([{ role: "session", content: "save" }]);
+        //If there was an existing cache, we rename it with new hash that includes the current message
+        if (existingCache !== null &&
+            existingCache.cachePath !== currentCacheInfo.cachePath) {
+            await renameCacheFile(existingCache.cachePath, currentCacheInfo.cachePath);
+        }
+        const responseWithStats = response;
+        return {
+            timeToFirstToken: responseWithStats.stats?.TTFT ?? 0,
+            tokensPerSecond: responseWithStats.stats?.TPS ?? 0,
+        };
+    }
+    else {
+        const response = await model.run(transformedHistory);
+        for await (const token of response.iterate()) {
+            yield token;
+        }
+        const responseWithStats = response;
+        return {
+            timeToFirstToken: responseWithStats.stats?.TTFT ?? 0,
+            tokensPerSecond: responseWithStats.stats?.TPS ?? 0,
+        };
+    }
+}

package/dist/server/bare/addons/llamacpp/handlers/embed.d.ts

@@ -0,0 +1,4 @@
+import { type EmbedParams } from "../../../../../schemas/index";
+export declare function embed(params: EmbedParams): Promise<number[]>;
+export declare function normalizeVector(vector: Float32Array): number[];
+//# sourceMappingURL=embed.d.ts.map

package/dist/server/bare/addons/llamacpp/handlers/embed.js

@@ -0,0 +1,40 @@
+import { getModel } from "../../../registry/model-registry.js";
+import { embedParamsSchema } from "../../../../../schemas/index.js";
+export async function embed(params) {
+    const { modelId, text } = embedParamsSchema.parse(params);
+    const model = getModel(modelId);
+    const response = await model.run(text);
+    const rawEmbeddings = (await response.await());
+    const embeddingVector = rawEmbeddings?.[0]?.[0];
+    if (!embeddingVector || embeddingVector.length === 0) {
+        throw new Error("No embeddings returned");
+    }
+    return normalizeVector(embeddingVector);
+}
+export function normalizeVector(vector) {
+    let sumOfSquares = 0;
+    for (let i = 0; i < vector.length; i++) {
+        const value = vector[i];
+        if (!Number.isFinite(value)) {
+            throw new Error(`NormalizeVector: non-finite value at index ${i}: ${value}`);
+        }
+        sumOfSquares += value * value;
+    }
+    const magnitude = Math.sqrt(sumOfSquares);
+    const EPS_ZERO = 1e-12;
+    const UNIT_TOL = 1e-4;
+    // Handle bad norms
+    if (!Number.isFinite(magnitude) || magnitude < EPS_ZERO) {
+        return new Array(vector.length).fill(0);
+    }
+    // Early exit: already ~unit length
+    if (Math.abs(magnitude - 1) <= UNIT_TOL) {
+        return Array.from(vector);
+    }
+    const inverseMagnitude = 1 / magnitude;
+    const normalizedVector = new Array(vector.length);
+    for (let i = 0; i < vector.length; i++) {
+        normalizedVector[i] = vector[i] * inverseMagnitude;
+    }
+    return normalizedVector;
+}

package/dist/server/bare/addons/llamacpp/index.d.ts

@@ -0,0 +1,4 @@
+export { completion } from "./handlers/completion-stream";
+export { embed } from "./handlers/embed";
+export { createLlmModel, createEmbeddingsModel } from "./create-model";
+//# sourceMappingURL=index.d.ts.map

package/dist/server/bare/addons/llamacpp/index.js

@@ -0,0 +1,3 @@
+export { completion } from "./handlers/completion-stream.js";
+export { embed } from "./handlers/embed.js";
+export { createLlmModel, createEmbeddingsModel } from "./create-model.js";

package/dist/server/bare/addons/llamacpp/kv-cache-utils.d.ts

@@ -0,0 +1,19 @@
+export interface CacheMessage {
+    role: string;
+    content: string;
+    attachments?: {
+        path: string;
+    }[] | undefined;
+}
+export declare function generateCacheKey(messages: CacheMessage[]): string;
+export declare function getCacheFilePath(cacheKey: string): string;
+export declare function findMatchingCache(currentHistory: CacheMessage[]): Promise<{
+    cacheKey: string;
+    cachePath: string;
+} | null>;
+export declare function getCurrentCacheInfo(currentHistory: CacheMessage[]): {
+    cacheKey: string;
+    cachePath: string;
+};
+export declare function renameCacheFile(oldPath: string, newPath: string): Promise<void>;
+//# sourceMappingURL=kv-cache-utils.d.ts.map

package/dist/server/bare/addons/llamacpp/kv-cache-utils.js

@@ -0,0 +1,46 @@
+import crypto from "bare-crypto";
+import { promises as fsPromises } from "bare-fs";
+import path from "bare-path";
+import { getKVCacheDir } from "../../../utils/index.js";
+export function generateCacheKey(messages) {
+    const hash = crypto.createHash("sha256");
+    const historyString = JSON.stringify(messages);
+    const historyBuffer = Buffer.from(historyString, "utf8");
+    hash.update(historyBuffer);
+    const hashString = hash.digest("hex");
+    return hashString.substring(0, 16);
+}
+export function getCacheFilePath(cacheKey) {
+    const cacheDir = getKVCacheDir();
+    return path.join(cacheDir, `kvcache${cacheKey}.bin`);
+}
+export async function findMatchingCache(currentHistory) {
+    if (currentHistory.length <= 1) {
+        return null;
+    }
+    // Generate cache key for history minus the last message
+    const previousHistory = currentHistory.slice(0, -1);
+    const cacheKey = generateCacheKey(previousHistory);
+    const cachePath = getCacheFilePath(cacheKey);
+    try {
+        await fsPromises.access(cachePath);
+        return { cacheKey, cachePath };
+    }
+    catch {
+        return null;
+    }
+}
+export function getCurrentCacheInfo(currentHistory) {
+    // Generate cache path for the current conversation state
+    const cacheKey = generateCacheKey(currentHistory);
+    const cachePath = getCacheFilePath(cacheKey);
+    return { cacheKey, cachePath };
+}
+export async function renameCacheFile(oldPath, newPath) {
+    try {
+        await fsPromises.rename(oldPath, newPath);
+    }
+    catch (error) {
+        console.error("Error renaming cache file:", error instanceof Error ? error.message : String(error));
+    }
+}

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

@@ -0,0 +1,3 @@
+import { type LoadModelServerParams } from "../../../schemas/index";
+export declare function loadModel(params: LoadModelServerParams): Promise<void>;
+//# sourceMappingURL=load-model.d.ts.map

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

@@ -0,0 +1,55 @@
+import { promises as fsPromises } from "bare-fs";
+import path from "bare-path";
+import process from "bare-process";
+import { registerModel, isModelLoaded, } from "../registry/model-registry.js";
+import { loadModelServerParamsSchema, } from "../../../schemas/index.js";
+import { createWhisperModel } from "./whispercpp/index.js";
+import { createLlmModel } from "./llamacpp/index.js";
+import { createEmbeddingsModel } from "./llamacpp/index.js";
+import { createNmtModel } from "./translation/index.js";
+export async function loadModel(params) {
+    const { modelId, modelPath, options, projectionModelPath, vadModelPath } = loadModelServerParamsSchema.parse(params);
+    const { modelConfig, modelType } = options;
+    // Check if model is already loaded
+    if (isModelLoaded(modelId)) {
+        console.log(`${modelType} model ${modelId} is already loaded`);
+        return;
+    }
+    // Validate the file exists
+    console.log("cwd", process.cwd());
+    try {
+        const modelDir = path.dirname(modelPath);
+        const modelFile = path.basename(modelPath);
+        const files = (await fsPromises.readdir(modelDir));
+        if (!files.includes(modelFile)) {
+            throw new Error(`${modelType} model file ${modelFile} not found in directory ${modelDir}`);
+        }
+        // File exists, continue
+    }
+    catch (error) {
+        console.error(`Error reading ${modelType} model directory:`, error instanceof Error ? error.message : String(error));
+        throw new Error(`Failed to locate ${modelType} model file: ${modelPath}`);
+    }
+    let model;
+    switch (modelType) {
+        case "llm":
+            model = createLlmModel(modelId, modelPath, modelConfig, projectionModelPath);
+            break;
+        case "whisper":
+            model = createWhisperModel(modelId, modelPath, modelConfig, vadModelPath);
+            break;
+        case "embeddings":
+            model = createEmbeddingsModel(modelId, modelPath, modelConfig);
+            break;
+        case "nmt":
+            model = createNmtModel(modelId, modelPath, modelConfig);
+            break;
+        default:
+            // Should never happen
+            throw new Error(`Unknown model type`);
+    }
+    console.log(`${modelType}: Loading model ${modelId}...`);
+    await model.load(false);
+    console.log(`${modelType} model ${modelId} loaded`);
+    registerModel(modelId, { model, path: modelPath });
+}

package/dist/server/bare/addons/translation/create-model.d.ts

@@ -0,0 +1,4 @@
+import { type AnyModel } from "../../registry/model-registry";
+import { type NmtConfig } from "../../../../schemas/index";
+export declare function createNmtModel(modelId: string, modelPath: string, nmtConfig: NmtConfig): AnyModel;
+//# sourceMappingURL=create-model.d.ts.map

package/dist/server/bare/addons/translation/create-model.js

@@ -0,0 +1,45 @@
+import TranslationNmtcpp from "@qvac/translation-nmtcpp";
+import { Readable } from "bare-stream";
+import {} from "../../registry/model-registry.js";
+import { INDICTRANS_LANGUAGES } from "../../../../schemas/index.js";
+import { createStreamLogger } from "../../../../logging/index.js";
+import { parseModelPath } from "../../../utils/index.js";
+// Mimic qvac-lib-dl-filesystem functionality
+function createFilesystemDLMimic(options) {
+    return {
+        dirPath: options.dirPath,
+        getStream: () => {
+            return Promise.resolve(Readable.from([]));
+        },
+        ready: () => Promise.resolve(),
+        close: () => Promise.resolve(),
+        destroy: () => Promise.resolve(),
+        start: () => Promise.resolve(),
+        stop: () => Promise.resolve(),
+    };
+}
+export function createNmtModel(modelId, modelPath, nmtConfig) {
+    const { dirPath, basePath } = parseModelPath(modelPath);
+    const dl = createFilesystemDLMimic({
+        dirPath: "./",
+    });
+    const logger = createStreamLogger(modelId, "nmtcpp");
+    const args = {
+        loader: dl,
+        logger,
+        modelName: basePath,
+        diskPath: dirPath,
+        params: {
+            mode: nmtConfig.mode,
+            srcLang: nmtConfig.from,
+            dstLang: nmtConfig.to,
+        },
+    };
+    const config = {
+        modelType: INDICTRANS_LANGUAGES.includes(nmtConfig.from) &&
+            INDICTRANS_LANGUAGES.includes(nmtConfig.to)
+            ? TranslationNmtcpp.ModelTypes.IndicTrans
+            : TranslationNmtcpp.ModelTypes.Opus,
+    };
+    return new TranslationNmtcpp(args, config);
+}

package/dist/server/bare/addons/translation/handlers/translate.d.ts

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