@qvac/sdk 0.4.1 → 0.6.0

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

@@ -1,5 +1,6 @@
 import {} from "../../../../../schemas/index.js";
-import { customCacheExists, extractSystemPrompt, findMatchingCache, generateConfigHash, getCacheFilePath, getCurrentCacheInfo, renameCacheFile, } from "../kv-cache-utils.js";
+import { logCacheDisabled, logCacheInit, logCacheSave, logCacheStatus, logMessagesToAddon, } from "../cache-logger.js";
+import { customCacheExists, extractSystemPrompt, findMatchingCache, generateConfigHash, getCacheFilePath, getCurrentCacheInfo, markCacheInitialized, renameCacheFile, } from "../kv-cache-utils.js";
 import { getModel, getModelConfig, } from "../../../registry/model-registry.js";
 import { checkForToolEvents, insertToolsIntoHistory, setupToolGrammar, } from "../../../../utils/tool-integration.js";
 import { parseToolCalls } from "../../../../utils/tool-parser.js";
@@ -43,15 +44,19 @@ function transformMessages(messages) {
     }
     return transformed;
 }
-async function initSystemPromptCache(model, cachePathToUse, systemPromptToUse, tools) {
+async function initSystemPromptCache(model, cachePathToUse, systemPromptToUse, cacheKey, tools) {
     const primeMessages = [
         { role: "session", content: cachePathToUse },
         { role: "system", content: systemPromptToUse },
     ];
+    let toolCount = 0;
     if (tools && tools.length > 0) {
         const transformedTools = transformMessages(tools);
         primeMessages.push(...transformedTools);
+        toolCount = tools.length;
     }
+    logCacheInit(cacheKey, systemPromptToUse, toolCount);
+    logMessagesToAddon(primeMessages, "CACHE_INIT");
     const primeResponse = await model.run(primeMessages);
     primeResponse.once("output", () => {
         void primeResponse.cancel();
@@ -95,6 +100,10 @@ async function* processModelResponse(model, messagesToSend, shouldSaveCache, too
         toolCallsResult = toolCalls;
     }
     if (shouldSaveCache) {
+        const sessionMsg = messagesToSend.find((m) => m.role === "session");
+        if (sessionMsg?.content) {
+            logCacheSave(sessionMsg.content);
+        }
         await model.run([{ role: "session", content: "save" }]);
     }
     const responseWithStats = response;
@@ -119,18 +128,22 @@ export async function* completion(params) {
     if (kvCache) {
         const modelConfig = getModelConfig(modelId);
         const systemPromptFromHistory = extractSystemPrompt(history);
-        const configHash = generateConfigHash(modelConfig, systemPromptFromHistory, tools);
+        const configHash = generateConfigHash(systemPromptFromHistory, tools);
         const systemPromptToUse = systemPromptFromHistory ||
             modelConfig.system_prompt ||
             "You are a helpful assistant.";
         let cachePathToUse;
         if (typeof kvCache === "string") {
             cachePathToUse = await getCacheFilePath(modelId, configHash, kvCache);
-            const cacheExists = await customCacheExists(modelId, configHash, kvCache);
+            let cacheExists = await customCacheExists(modelId, configHash, kvCache);
+            logCacheStatus(kvCache, cacheExists);
             if (!cacheExists) {
-                await initSystemPromptCache(model, cachePathToUse, systemPromptToUse, tools && toolsEnabled ? tools : undefined);
+                await initSystemPromptCache(model, cachePathToUse, systemPromptToUse, kvCache, tools && toolsEnabled ? tools : undefined);
+                markCacheInitialized(modelId, configHash, kvCache);
+                cacheExists = true;
             }
             const messagesToSend = prepareMessagesForCache(cachePathToUse, cacheExists, history);
+            logMessagesToAddon(messagesToSend, "PROMPT_SEND");
             return yield* processModelResponse(model, messagesToSend, true, tools);
         }
         else {
@@ -146,11 +159,15 @@ export async function* completion(params) {
                 existingCache !== null
                     ? existingCache.cachePath
                     : currentCacheInfo.cachePath;
-            const cacheExists = existingCache !== null;
+            let cacheExists = existingCache !== null;
+            logCacheStatus("auto", cacheExists);
             if (!cacheExists) {
-                await initSystemPromptCache(model, cachePathToUse, systemPromptToUse, tools && toolsEnabled ? tools : undefined);
+                await initSystemPromptCache(model, cachePathToUse, systemPromptToUse, "auto", tools && toolsEnabled ? tools : undefined);
+                markCacheInitialized(modelId, configHash, currentCacheInfo.cacheKey);
+                cacheExists = true;
             }
             const messagesToSend = prepareMessagesForCache(cachePathToUse, cacheExists, history);
+            logMessagesToAddon(messagesToSend, "PROMPT_SEND");
             const result = yield* processModelResponse(model, messagesToSend, true, tools);
             //If there was an existing cache, we rename it with new hash that includes the current message
             if (existingCache !== null &&
@@ -161,6 +178,8 @@ export async function* completion(params) {
         }
     }
     else {
+        logCacheDisabled();
+        logMessagesToAddon(transformedHistory, "NO_CACHE");
         return yield* processModelResponse(model, transformedHistory, false, tools);
     }
 }

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

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

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

@@ -0,0 +1,3 @@
+export { completion } from "./handlers/completion-stream.js";
+export { createLlmModel } from "./create-model.js";
+export { deleteCache } from "./kv-cache-utils.js";

package/dist/server/bare/addons/{llamacpp → llamacpp-completion}/kv-cache-utils.d.ts

@@ -1,3 +1,6 @@
+export declare function markCacheInitialized(modelId: string, configHash: string, cacheKey: string): void;
+export declare function isCacheInitialized(modelId: string, configHash: string, cacheKey: string): boolean;
+export declare function clearCacheRegistry(cacheKey?: string): void;
 export interface CacheMessage {
     role: string;
     content: string;
@@ -6,7 +9,7 @@ export interface CacheMessage {
     }[] | undefined;
 }
 export declare function extractSystemPrompt(messages: CacheMessage[]): string | null;
-export declare function generateConfigHash(modelConfig: unknown, systemPrompt: string | null, tools?: unknown): string;
+export declare function generateConfigHash(systemPrompt: string | null, tools?: unknown): string;
 export declare function generateCacheKey(messages: CacheMessage[]): string;
 export declare function getCacheFilePath(modelId: string, configHash: string, cacheKey: string): Promise<string>;
 export declare function findMatchingCache(modelId: string, configHash: string, currentHistory: CacheMessage[]): Promise<{

package/dist/server/bare/addons/{llamacpp → llamacpp-completion}/kv-cache-utils.js

@@ -2,21 +2,50 @@ import crypto from "bare-crypto";
 import { promises as fsPromises } from "bare-fs";
 import path from "bare-path";
 import { getKVCacheDir } from "../../../utils/index.js";
+import { getServerLogger } from "../../../../logging/index.js";
+const logger = getServerLogger();
+// In-memory registry tracks caches initialized this session (addon defers disk writes)
+const initializedCaches = new Set();
+function getCacheRegistryKey(modelId, configHash, cacheKey) {
+    return `${modelId}:${configHash}:${cacheKey}`;
+}
+export function markCacheInitialized(modelId, configHash, cacheKey) {
+    initializedCaches.add(getCacheRegistryKey(modelId, configHash, cacheKey));
+}
+export function isCacheInitialized(modelId, configHash, cacheKey) {
+    return initializedCaches.has(getCacheRegistryKey(modelId, configHash, cacheKey));
+}
+export function clearCacheRegistry(cacheKey) {
+    if (cacheKey) {
+        for (const key of initializedCaches) {
+            if (key.includes(`:${cacheKey}`)) {
+                initializedCaches.delete(key);
+            }
+        }
+    }
+    else {
+        initializedCaches.clear();
+    }
+}
 export function extractSystemPrompt(messages) {
     const systemMessage = messages.find((msg) => msg.role === "system");
     return systemMessage ? systemMessage.content : null;
 }
-export function generateConfigHash(modelConfig, systemPrompt, tools) {
+function getToolNamesForHash(tools) {
+    if (!Array.isArray(tools))
+        return [];
+    return tools
+        .map((t) => t.name)
+        .filter((n) => typeof n === "string")
+        .sort();
+}
+// Cache hash based on system prompt + tool names
+// Different tools = different cache (tools anchored in first message, protected from n_discarded)
+export function generateConfigHash(systemPrompt, tools) {
     const hash = crypto.createHash("sha256");
-    const configStr = JSON.stringify({
-        config: modelConfig,
-        systemPrompt,
-        tools,
-    });
-    const configBuffer = Buffer.from(configStr, "utf8");
-    hash.update(configBuffer);
-    const hashString = hash.digest("hex");
-    return hashString.substring(0, 16);
+    const toolNames = getToolNamesForHash(tools);
+    hash.update(Buffer.from(JSON.stringify({ systemPrompt, toolNames }), "utf8"));
+    return hash.digest("hex").substring(0, 16);
 }
 export function generateCacheKey(messages) {
     const hash = crypto.createHash("sha256");
@@ -66,13 +95,19 @@ export async function renameCacheFile(oldPath, newPath) {
         await fsPromises.rename(oldPath, newPath);
     }
     catch (error) {
-        console.error("Error renaming cache file:", error instanceof Error ? error.message : String(error));
+        logger.error("Error renaming cache file:", error instanceof Error ? error.message : String(error));
     }
 }
 export async function customCacheExists(modelId, configHash, cacheKey) {
+    // Check in-memory registry first (addon defers disk writes)
+    if (isCacheInitialized(modelId, configHash, cacheKey)) {
+        return true;
+    }
+    // Then check file system (for caches from previous runs)
     const cachePath = await getCacheFilePath(modelId, configHash, cacheKey);
     try {
         await fsPromises.access(cachePath);
+        markCacheInitialized(modelId, configHash, cacheKey);
         return true;
     }
     catch {
@@ -87,7 +122,7 @@ export async function deleteCache(options) {
             await fsPromises.mkdir(cacheDir, { recursive: true });
         }
         catch (error) {
-            console.error("Error deleting all caches:", error instanceof Error ? error.message : String(error));
+            logger.error("Error deleting all caches:", error instanceof Error ? error.message : String(error));
         }
     }
     else if ("kvCacheKey" in options) {
@@ -98,7 +133,7 @@ export async function deleteCache(options) {
                 await fsPromises.rm(modelCacheDir, { recursive: true });
             }
             catch (error) {
-                console.error(`Error deleting model cache ${options.kvCacheKey}/${options.modelId}:`, error instanceof Error ? error.message : String(error));
+                logger.error(`Error deleting model cache ${options.kvCacheKey}/${options.modelId}:`, error instanceof Error ? error.message : String(error));
             }
         }
         else {
@@ -106,7 +141,7 @@ export async function deleteCache(options) {
                 await fsPromises.rm(kvCacheDir, { recursive: true });
             }
             catch (error) {
-                console.error(`Error deleting cache ${options.kvCacheKey}:`, error instanceof Error ? error.message : String(error));
+                logger.error(`Error deleting cache ${options.kvCacheKey}:`, error instanceof Error ? error.message : String(error));
             }
         }
     }

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

@@ -0,0 +1,8 @@
+import type { AnyModel } from "../../registry/model-registry";
+import type { EmbedConfig } from "../../../../schemas/index";
+import FilesystemDL from "@qvac/dl-filesystem";
+export declare function createEmbeddingsModel(modelId: string, modelPath: string, embedConfig: EmbedConfig): {
+    model: AnyModel;
+    loader: FilesystemDL;
+};
+//# sourceMappingURL=create-model.d.ts.map

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

@@ -0,0 +1,38 @@
+import EmbedLlamacpp, {} from "@qvac/embed-llamacpp";
+import { ADDON_NAMESPACES, registerAddonLogger, createStreamLogger, } from "../../../../logging/index.js";
+import { parseModelPath } from "../../../utils/index.js";
+import FilesystemDL from "@qvac/dl-filesystem";
+import { asLoader } from "../../utils/loader-adapter.js";
+function transformEmbedConfig(embedConfig) {
+    if (embedConfig.rawConfig) {
+        return embedConfig.rawConfig;
+    }
+    const lines = [];
+    lines.push(`-ngl\t${embedConfig.gpuLayers}`);
+    lines.push(`-dev\t${embedConfig.device}`);
+    lines.push(`--batch_size\t${embedConfig.batchSize}`);
+    if (embedConfig.ctxSize) {
+        lines.push(`-c\t${embedConfig.ctxSize}`);
+    }
+    if (embedConfig.flashAttention) {
+        lines.push(`-fa\t${embedConfig.flashAttention}`);
+    }
+    return lines.join("\n");
+}
+export function createEmbeddingsModel(modelId, modelPath, embedConfig) {
+    const { dirPath, basePath } = parseModelPath(modelPath);
+    const loader = new FilesystemDL({ dirPath });
+    const logger = createStreamLogger(modelId, ADDON_NAMESPACES.LLAMACPP_EMBED);
+    registerAddonLogger(modelId, ADDON_NAMESPACES.LLAMACPP_EMBED, logger);
+    const config = transformEmbedConfig(embedConfig);
+    const args = {
+        loader: asLoader(loader),
+        opts: { stats: true },
+        logger,
+        diskPath: dirPath,
+        modelName: basePath,
+        modelPath,
+    };
+    const model = new EmbedLlamacpp(args, config);
+    return { model, loader };
+}

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

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

package/dist/server/bare/addons/{llamacpp → llamacpp-embedding}/handlers/embed.js

@@ -6,11 +6,25 @@ export async function embed(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 EmbedNoEmbeddingsError();
+    const embeddingsArray = rawEmbeddings[0];
+    if (Array.isArray(text)) {
+        if (!embeddingsArray || embeddingsArray.length === 0) {
+            throw new EmbedNoEmbeddingsError();
+        }
+        return embeddingsArray.map((embeddingVector) => {
+            if (!embeddingVector || embeddingVector.length === 0) {
+                throw new EmbedNoEmbeddingsError();
+            }
+            return normalizeVector(embeddingVector);
+        });
+    }
+    else {
+        const embeddingVector = embeddingsArray?.[0];
+        if (!embeddingVector || embeddingVector.length === 0) {
+            throw new EmbedNoEmbeddingsError();
+        }
+        return normalizeVector(embeddingVector);
     }
-    return normalizeVector(embeddingVector);
 }
 export function normalizeVector(vector) {
     let sumOfSquares = 0;

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

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

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

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

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

@@ -1,19 +1,24 @@
-import { loadModelServerParamsSchema, } from "../../../schemas/index.js";
-import { createEmbeddingsModel, createLlmModel, } from "./llamacpp/index.js";
-import { createNmtModel } from "./translation/index.js";
-import { createTtsModel } from "./tts/index.js";
-import { createWhisperModel } from "./whispercpp/index.js";
+import { loadModelServerParamsSchema, ModelType, } from "../../../schemas/index.js";
+import { createLlmModel } from "./llamacpp-completion/index.js";
+import { createEmbeddingsModel } from "./llamacpp-embedding/index.js";
+import { createNmtModel } from "./nmtcpp-translation/index.js";
+import { createTtsModel } from "./onnx-tts/index.js";
+import { createWhisperModel } from "./whispercpp-transcription/index.js";
+import { createOCRModel } from "./onnx-ocr/index.js";
 import { isModelLoaded, registerModel, } from "../registry/model-registry.js";
-import { detectShardedModel, generateShardFilenames } from "../../utils/index.js";
-import { ESpeakDataPathRequiredError, UnknownModelTypeError, ModelFileNotFoundError, ModelFileNotFoundInDirError, ModelFileLocateFailedError, } from "../../../utils/errors-server.js";
+import { startLogBuffering, stopLogBufferingWithTimeout, } from "../registry/logging-stream-registry.js";
+import { detectShardedModel, generateShardFilenames, validateShardedModelCache, } from "../../utils/index.js";
+import { ESpeakDataPathRequiredError, ModelLoadFailedError, UnknownModelTypeError, ModelFileNotFoundError, ModelFileNotFoundInDirError, ModelFileLocateFailedError, } from "../../../utils/errors-server.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, ttsConfigModelPath, eSpeakDataPath, modelName, } = loadModelServerParamsSchema.parse(params);
+    const { modelId, modelPath, options, projectionModelPath, vadModelPath, ttsConfigModelPath, eSpeakDataPath, detectorModelPath, modelName, } = loadModelServerParamsSchema.parse(params);
     const { modelConfig, modelType } = options;
     // Check if model is already loaded
     if (isModelLoaded(modelId)) {
-        console.log(`${modelType} model ${modelId} is already loaded`);
+        logger.info(`${modelType} model ${modelId} is already loaded`);
         return;
     }
     // Detect if sharded model
@@ -21,17 +26,12 @@ export async function loadModel(params) {
     const shardInfo = detectShardedModel(modelFileName);
     const isShardedModel = shardInfo.isSharded;
     if (isShardedModel) {
-        // For sharded models, validate all required files exist
+        // For sharded models, validate all shards and tensors.txt exist
         const shardDir = path.dirname(modelPath);
-        const allRequiredFiles = generateShardFilenames(modelFileName);
-        for (const shardFile of allRequiredFiles) {
-            const shardPath = path.join(shardDir, shardFile);
-            try {
-                await fsPromises.access(shardPath);
-            }
-            catch (error) {
-                throw new ModelFileNotFoundError(`${shardFile}. Expected ${allRequiredFiles.length} files (shards + companion files) in ${shardDir}`, error);
-            }
+        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 {
@@ -45,41 +45,51 @@ export async function loadModel(params) {
             }
         }
         catch (error) {
-            console.error(`Error reading ${modelType} model directory:`, error instanceof Error ? error.message : String(error));
+            logger.error(`Error reading ${modelType} model directory:`, error instanceof Error ? error.message : String(error));
             throw new ModelFileLocateFailedError(modelType, modelPath, error);
         }
     }
     let result;
     switch (modelType) {
-        case "llm":
+        case ModelType.llamacppCompletion:
             result = createLlmModel(modelId, modelPath, modelConfig, projectionModelPath);
             break;
-        case "whisper":
+        case ModelType.whispercppTranscription:
             result = createWhisperModel(modelId, modelPath, modelConfig, vadModelPath);
             break;
-        case "embeddings":
+        case ModelType.llamacppEmbedding:
             result = createEmbeddingsModel(modelId, modelPath, modelConfig);
             break;
-        case "nmt":
+        case ModelType.nmtcppTranslation:
             result = createNmtModel(modelId, modelPath, modelConfig);
             break;
-        case "tts":
+        case ModelType.onnxTts:
             if (!eSpeakDataPath) {
                 throw new ESpeakDataPathRequiredError();
             }
             result = createTtsModel(modelId, modelPath, modelConfig, ttsConfigModelPath, eSpeakDataPath);
             break;
+        case ModelType.onnxOcr:
+            if (!detectorModelPath) {
+                throw new ModelLoadFailedError("Detector model required for OCR. Use a hyperdrive source or provide detectorModelSrc");
+            }
+            // modelPath is the recognizer, detectorModelPath is auto-derived
+            result = createOCRModel(modelId, detectorModelPath, modelPath, modelConfig);
+            break;
         default:
-            // Should never happen
+            // Should never happen - normalizeModelType validates input
             throw new UnknownModelTypeError(modelType);
     }
-    console.log(`${modelType}: Loading model ${modelId}...`);
+    logger.info(`${modelType}: Loading model ${modelId}...`);
+    startLogBuffering(modelId);
     await result.model.load(false);
-    console.log(`${modelType} model ${modelId} loaded`);
+    logger.info(`${modelType} model ${modelId} loaded`);
+    stopLogBufferingWithTimeout(modelId);
     registerModel(modelId, {
         model: result.model,
         path: modelPath,
         config: modelConfig,
+        modelType,
         name: modelName,
         loader: result.loader,
     });

package/dist/server/bare/addons/{translation → nmtcpp-translation}/create-model.js

@@ -1,17 +1,18 @@
-import TranslationNmtcpp from "@qvac/translation-nmtcpp";
+import TranslationNmtcpp, {} from "@qvac/translation-nmtcpp";
 import {} from "../../registry/model-registry.js";
-import { INDICTRANS_LANGUAGES } from "../../../../schemas/index.js";
+import {} from "../../../../schemas/index.js";
 import { createStreamLogger } from "../../../../logging/index.js";
 import { parseModelPath } from "../../../utils/index.js";
 import FilesystemDL from "@qvac/dl-filesystem";
 import { TranslationFailedError } from "../../../../utils/errors-server.js";
+import { asLoader } from "../../utils/loader-adapter.js";
 export function createNmtModel(modelId, modelPath, nmtConfig) {
     const { dirPath, basePath } = parseModelPath(modelPath);
     const loader = new FilesystemDL({ dirPath });
     const logger = createStreamLogger(modelId, "nmtcpp");
-    const { mode, from, to, ...generationParams } = nmtConfig;
+    const { mode, from, to, engine, beamsize, lengthpenalty, maxlength, repetitionpenalty, norepeatngramsize, temperature, topk, topp, } = nmtConfig;
     const args = {
-        loader,
+        loader: asLoader(loader),
         logger,
         modelName: basePath,
         diskPath: dirPath,
@@ -21,12 +22,26 @@ export function createNmtModel(modelId, modelPath, nmtConfig) {
             dstLang: to,
         },
     };
+    const generationParams = {
+        beamsize,
+        lengthpenalty,
+        maxlength,
+        repetitionpenalty,
+        norepeatngramsize,
+        temperature,
+        topk,
+        topp,
+    };
     const config = {
-        modelType: INDICTRANS_LANGUAGES.includes(from) &&
-            INDICTRANS_LANGUAGES.includes(to)
-            ? TranslationNmtcpp.ModelTypes.IndicTrans
-            : TranslationNmtcpp.ModelTypes.Opus,
+        modelType: TranslationNmtcpp.ModelTypes[engine],
         ...generationParams,
+        ...(nmtConfig.engine === "Bergamot" && {
+            ...(nmtConfig.srcVocabPath && { srcVocabPath: nmtConfig.srcVocabPath }),
+            ...(nmtConfig.dstVocabPath && { dstVocabPath: nmtConfig.dstVocabPath }),
+            ...(nmtConfig.normalize !== undefined && {
+                normalize: nmtConfig.normalize,
+            }),
+        }),
     };
     // Fail fast if model type is IndicTrans
     if (config.modelType === TranslationNmtcpp.ModelTypes.IndicTrans) {

package/dist/server/bare/addons/{translation → nmtcpp-translation}/handlers/translate.js

@@ -1,5 +1,5 @@
 import { getModel } from "../../../registry/model-registry.js";
-import { translateServerParamsSchema, } from "../../../../../schemas/index.js";
+import { translateServerParamsSchema, normalizeModelType, ModelType, } from "../../../../../schemas/index.js";
 import { getLangName } from "@qvac/langdetect-text";
 function getLanguage(code) {
     if (!code)
@@ -8,28 +8,52 @@ function getLanguage(code) {
     return fullName ?? code.toUpperCase();
 }
 export async function* translate(params) {
-    const { modelId, text, modelType } = params;
-    const from = params.modelType === "llm" ? params.from : undefined;
-    const to = params.modelType === "llm" ? params.to : undefined;
-    const context = params.modelType === "llm" ? params.context : undefined;
+    const { modelId, text, modelType: inputModelType } = params;
+    const canonicalModelType = normalizeModelType(inputModelType);
+    const isLlm = canonicalModelType === ModelType.llamacppCompletion;
+    const from = isLlm ? params.from : undefined;
+    const to = isLlm ? params.to : undefined;
+    const context = isLlm ? params.context : undefined;
     translateServerParamsSchema.parse(params);
     const model = getModel(modelId);
     const fromLanguage = getLanguage(from);
     const toLanguage = getLanguage(to);
+    const startTime = Date.now();
+    let processedTokens = 0;
+    // Check if input is an array and model type is NMT
+    if (Array.isArray(text) &&
+        canonicalModelType === ModelType.nmtcppTranslation) {
+        // Use runBatch for batch processing
+        const translations = await model.runBatch(text);
+        // Yield each translation with a newline separator
+        for (const translation of translations) {
+            processedTokens++;
+            yield translation;
+            if (translations.indexOf(translation) < translations.length - 1) {
+                yield "\n";
+            }
+        }
+        const endTime = Date.now();
+        return {
+            processedTokens,
+            processingTime: endTime - startTime,
+        };
+    }
+    // Single text processing (for NMT or LLM)
+    const singleText = Array.isArray(text) ? text[0] : text;
     // Prepare input based on model type
-    const input = modelType === "nmt"
-        ? text
+    const input = canonicalModelType === ModelType.nmtcppTranslation
+        ? singleText
         : [
             {
                 role: "system",
-                content: `${context ? `${context}. ` : ""}Translate the following text from ${fromLanguage} into ${toLanguage}. Only output the translation, nothing else.\n\n${fromLanguage}: ${text}\n${toLanguage}:`,
+                content: `${context ? `${context}. ` : ""}Translate the following text from ${fromLanguage} into ${toLanguage}. Only output the translation, nothing else.\n\n${fromLanguage}: ${singleText}\n${toLanguage}:`,
             },
         ];
-    const startTime = Date.now();
-    let processedTokens = 0;
     const response = await model.run(input);
     // Check if the response has an iterate method (like LLM models)
-    if (modelType === "llm" && typeof response.iterate === "function") {
+    if (canonicalModelType === ModelType.llamacppCompletion &&
+        typeof response.iterate === "function") {
         for await (const token of response.iterate()) {
             processedTokens++;
             yield token;

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

@@ -0,0 +1,10 @@
+import type { OCRConfig } from "../../../../schemas/ocr";
+import { type AnyModel } from "../../registry/model-registry";
+import FilesystemDL from "@qvac/dl-filesystem";
+import { ONNXOcr } from "@qvac/ocr-onnx";
+export type OCRModel = ONNXOcr;
+export declare function createOCRModel(modelId: string, detectorPath: string, recognizerPath: string, ocrConfig: OCRConfig): {
+    model: AnyModel;
+    loader: FilesystemDL;
+};
+//# sourceMappingURL=create-model.d.ts.map

package/dist/server/bare/addons/onnx-ocr/create-model.js

@@ -0,0 +1,39 @@
+import {} from "../../registry/model-registry.js";
+import { createStreamLogger } from "../../../../logging/index.js";
+import { parseModelPath } from "../../../utils/index.js";
+import FilesystemDL from "@qvac/dl-filesystem";
+import { ONNXOcr } from "@qvac/ocr-onnx";
+export function createOCRModel(modelId, detectorPath, recognizerPath, ocrConfig) {
+    const { dirPath } = parseModelPath(detectorPath);
+    const loader = new FilesystemDL({ dirPath });
+    const logger = createStreamLogger(modelId, "ocr");
+    const params = {
+        pathDetector: detectorPath,
+        pathRecognizer: recognizerPath,
+        langList: ocrConfig.langList || ["en"],
+        useGPU: ocrConfig.useGPU ?? true,
+        ...(ocrConfig.timeout !== undefined && { timeout: ocrConfig.timeout }),
+        ...(ocrConfig.magRatio !== undefined && { magRatio: ocrConfig.magRatio }),
+        ...(ocrConfig.defaultRotationAngles !== undefined && {
+            defaultRotationAngles: ocrConfig.defaultRotationAngles,
+        }),
+        ...(ocrConfig.contrastRetry !== undefined && {
+            contrastRetry: ocrConfig.contrastRetry,
+        }),
+        ...(ocrConfig.lowConfidenceThreshold !== undefined && {
+            lowConfidenceThreshold: ocrConfig.lowConfidenceThreshold,
+        }),
+        ...(ocrConfig.recognizerBatchSize !== undefined && {
+            recognizerBatchSize: ocrConfig.recognizerBatchSize,
+        }),
+    };
+    const args = {
+        loader: loader,
+        logger,
+        params,
+        opts: { stats: true },
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+    const model = new ONNXOcr(args);
+    return { model, loader };
+}

package/dist/server/bare/addons/onnx-ocr/handlers/ocr-stream.d.ts

@@ -0,0 +1,10 @@
+import type { OCRParams, OCRTextBlock } from "../../../../../schemas/ocr";
+export declare function ocr(params: OCRParams): AsyncGenerator<{
+    blocks: OCRTextBlock[];
+    stats?: {
+        detectionTime?: number;
+        recognitionTime?: number;
+        totalTime?: number;
+    };
+}, void, void>;
+//# sourceMappingURL=ocr-stream.d.ts.map