@qvac/sdk 0.7.1 → 0.8.0

package/dist/server/bare/plugins/nmtcpp-translation/plugin.d.ts

@@ -1,8 +1,330 @@
-import { type CreateModelParams, type PluginModelResult } from "../../../../schemas/index";
+import { type CreateModelParams, type PluginModelResult, type ResolveContext, type ResolveResult } from "../../../../schemas/index";
 export declare const nmtPlugin: {
     modelType: "nmtcpp-translation";
     displayName: string;
-    addonPackage: string;
+    addonPackage: "@qvac/translation-nmtcpp";
+    loadConfigSchema: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        mode: import("zod").ZodOptional<import("zod").ZodEnum<{
+            full: "full";
+        }>>;
+        beamsize: import("zod").ZodOptional<import("zod").ZodNumber>;
+        lengthpenalty: import("zod").ZodOptional<import("zod").ZodNumber>;
+        maxlength: import("zod").ZodOptional<import("zod").ZodNumber>;
+        repetitionpenalty: import("zod").ZodOptional<import("zod").ZodNumber>;
+        norepeatngramsize: import("zod").ZodOptional<import("zod").ZodNumber>;
+        temperature: import("zod").ZodOptional<import("zod").ZodNumber>;
+        topk: import("zod").ZodOptional<import("zod").ZodNumber>;
+        topp: import("zod").ZodOptional<import("zod").ZodNumber>;
+        engine: import("zod").ZodLiteral<"Opus">;
+        from: import("zod").ZodEnum<{
+            en: "en";
+            de: "de";
+            es: "es";
+            it: "it";
+            ru: "ru";
+            ja: "ja";
+        }>;
+        to: import("zod").ZodEnum<{
+            en: "en";
+            de: "de";
+            es: "es";
+            it: "it";
+            ru: "ru";
+            ja: "ja";
+        }>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        mode: import("zod").ZodOptional<import("zod").ZodEnum<{
+            full: "full";
+        }>>;
+        beamsize: import("zod").ZodOptional<import("zod").ZodNumber>;
+        lengthpenalty: import("zod").ZodOptional<import("zod").ZodNumber>;
+        maxlength: import("zod").ZodOptional<import("zod").ZodNumber>;
+        repetitionpenalty: import("zod").ZodOptional<import("zod").ZodNumber>;
+        norepeatngramsize: import("zod").ZodOptional<import("zod").ZodNumber>;
+        temperature: import("zod").ZodOptional<import("zod").ZodNumber>;
+        topk: import("zod").ZodOptional<import("zod").ZodNumber>;
+        topp: import("zod").ZodOptional<import("zod").ZodNumber>;
+        engine: import("zod").ZodLiteral<"Bergamot">;
+        from: import("zod").ZodEnum<{
+            en: "en";
+            de: "de";
+            es: "es";
+            it: "it";
+            ru: "ru";
+            ja: "ja";
+            ar: "ar";
+            bg: "bg";
+            ca: "ca";
+            cs: "cs";
+            et: "et";
+            fi: "fi";
+            fr: "fr";
+            hu: "hu";
+            is: "is";
+            ko: "ko";
+            lt: "lt";
+            lv: "lv";
+            nl: "nl";
+            pl: "pl";
+            pt: "pt";
+            sk: "sk";
+            sl: "sl";
+            uk: "uk";
+            zh: "zh";
+        }>;
+        to: import("zod").ZodEnum<{
+            en: "en";
+            de: "de";
+            es: "es";
+            it: "it";
+            ru: "ru";
+            ja: "ja";
+            ar: "ar";
+            bg: "bg";
+            ca: "ca";
+            cs: "cs";
+            et: "et";
+            fi: "fi";
+            fr: "fr";
+            hu: "hu";
+            is: "is";
+            ko: "ko";
+            lt: "lt";
+            lv: "lv";
+            nl: "nl";
+            pl: "pl";
+            pt: "pt";
+            sk: "sk";
+            sl: "sl";
+            uk: "uk";
+            zh: "zh";
+        }>;
+        srcVocabSrc: 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>]>>;
+        dstVocabSrc: 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>]>>;
+        normalize: import("zod").ZodOptional<import("zod").ZodNumber>;
+        pivotModel: import("zod").ZodOptional<import("zod").ZodObject<{
+            mode: import("zod").ZodOptional<import("zod").ZodEnum<{
+                full: "full";
+            }>>;
+            beamsize: import("zod").ZodOptional<import("zod").ZodNumber>;
+            lengthpenalty: import("zod").ZodOptional<import("zod").ZodNumber>;
+            maxlength: import("zod").ZodOptional<import("zod").ZodNumber>;
+            repetitionpenalty: import("zod").ZodOptional<import("zod").ZodNumber>;
+            norepeatngramsize: import("zod").ZodOptional<import("zod").ZodNumber>;
+            temperature: import("zod").ZodOptional<import("zod").ZodNumber>;
+            topk: import("zod").ZodOptional<import("zod").ZodNumber>;
+            topp: import("zod").ZodOptional<import("zod").ZodNumber>;
+            modelSrc: 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>]>;
+            srcVocabSrc: 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>]>>;
+            dstVocabSrc: 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>]>>;
+            normalize: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        mode: import("zod").ZodOptional<import("zod").ZodEnum<{
+            full: "full";
+        }>>;
+        beamsize: import("zod").ZodOptional<import("zod").ZodNumber>;
+        lengthpenalty: import("zod").ZodOptional<import("zod").ZodNumber>;
+        maxlength: import("zod").ZodOptional<import("zod").ZodNumber>;
+        repetitionpenalty: import("zod").ZodOptional<import("zod").ZodNumber>;
+        norepeatngramsize: import("zod").ZodOptional<import("zod").ZodNumber>;
+        temperature: import("zod").ZodOptional<import("zod").ZodNumber>;
+        topk: import("zod").ZodOptional<import("zod").ZodNumber>;
+        topp: import("zod").ZodOptional<import("zod").ZodNumber>;
+        engine: import("zod").ZodLiteral<"IndicTrans">;
+        from: import("zod").ZodEnum<{
+            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: import("zod").ZodEnum<{
+            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";
+        }>;
+    }, import("zod/v4/core").$strip>], "engine">;
+    resolveConfig(cfg: Record<string, unknown>, ctx: ResolveContext): Promise<ResolveResult<Record<string, unknown>>>;
     createModel(params: CreateModelParams): PluginModelResult;
     handlers: {
         translate: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
@@ -39,7 +361,7 @@ export declare const nmtPlugin: {
     };
     logging: {
         module: import("@qvac/translation-nmtcpp/addonLogging").AddonLogging;
-        namespace: "nmtcpp";
+        namespace: "nmtcpp-translation";
     };
 };
 //# sourceMappingURL=plugin.d.ts.map

package/dist/server/bare/plugins/nmtcpp-translation/plugin.js

@@ -1,16 +1,44 @@
 import nmtAddonLogging from "@qvac/translation-nmtcpp/addonLogging.js";
 import TranslationNmtcpp, {} from "@qvac/translation-nmtcpp";
-import { definePlugin, defineHandler, translateRequestSchema, translateResponseSchema, ModelType, } from "../../../../schemas/index.js";
-import { ADDON_NAMESPACES, createStreamLogger } from "../../../../logging/index.js";
+import { definePlugin, defineHandler, translateRequestSchema, translateResponseSchema, ModelType, nmtConfigBaseSchema, ADDON_NMT, } from "../../../../schemas/index.js";
+import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
 import { parseModelPath } from "../../../utils/index.js";
 import FilesystemDL from "@qvac/dl-filesystem";
-import { TranslationFailedError } from "../../../../utils/errors-server.js";
+import { TranslationFailedError, ModelLoadFailedError, } from "../../../../utils/errors-server.js";
 import { asLoader } from "../../utils/loader-adapter.js";
 import { translate } from "../../ops/translate.js";
-function createNmtModel(modelId, modelPath, nmtConfig) {
+const BERGAMOT_CJK_LANG_PAIRS = ["enja", "enko", "enzh"];
+function buildBergamotVocabSources(basePath, langPair) {
+    if (BERGAMOT_CJK_LANG_PAIRS.includes(langPair)) {
+        return {
+            srcVocabSrc: `${basePath}srcvocab.${langPair}.spm`,
+            dstVocabSrc: `${basePath}trgvocab.${langPair}.spm`,
+        };
+    }
+    const sharedVocab = `${basePath}vocab.${langPair}.spm`;
+    return { srcVocabSrc: sharedVocab, dstVocabSrc: sharedVocab };
+}
+function deriveBergamotVocabSources(modelSrc) {
+    const match = modelSrc.match(/^pear:\/\/([a-f0-9]+)\/model\.([a-z]+)\.intgemm\.alphas\.bin$/);
+    if (!match?.[1] || !match[2])
+        return null;
+    const basePath = `pear://${match[1]}/`;
+    const langPair = match[2];
+    return buildBergamotVocabSources(basePath, langPair);
+}
+function deriveBergamotRegistryVocabSources(modelSrc) {
+    const match = modelSrc.match(/^(registry:\/\/.+\/)model\.([a-z]+)\.intgemm\.alphas\.bin$/);
+    if (!match?.[1] || !match[2])
+        return null;
+    const basePath = match[1];
+    const langPair = match[2];
+    return buildBergamotVocabSources(basePath, langPair);
+}
+function createNmtModel(modelId, modelPath, nmtConfig, srcVocabPath, dstVocabPath, pivotModelPath, pivotSrcVocabPath, pivotDstVocabPath) {
     const { dirPath, basePath } = parseModelPath(modelPath);
     const loader = new FilesystemDL({ dirPath });
-    const logger = createStreamLogger(modelId, "nmtcpp");
+    const logger = createStreamLogger(modelId, ModelType.nmtcppTranslation);
+    registerAddonLogger(modelId, ModelType.nmtcppTranslation, logger);
     const { mode, from, to, engine, beamsize, lengthpenalty, maxlength, repetitionpenalty, norepeatngramsize, temperature, topk, topp, } = nmtConfig;
     const args = {
         loader: asLoader(loader),
@@ -37,11 +65,29 @@ function createNmtModel(modelId, modelPath, nmtConfig) {
         modelType: TranslationNmtcpp.ModelTypes[engine],
         ...generationParams,
         ...(nmtConfig.engine === "Bergamot" && {
-            ...(nmtConfig.srcVocabPath && { srcVocabPath: nmtConfig.srcVocabPath }),
-            ...(nmtConfig.dstVocabPath && { dstVocabPath: nmtConfig.dstVocabPath }),
+            ...(srcVocabPath && { srcVocabPath }),
+            ...(dstVocabPath && { dstVocabPath }),
             ...(nmtConfig.normalize !== undefined && {
                 normalize: nmtConfig.normalize,
             }),
+            // Add pivot model configuration if present
+            ...(nmtConfig.pivotModel && {
+                bergamotPivotModel: (() => {
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    const { modelSrc, dstVocabSrc, srcVocabSrc, ...config } = nmtConfig.pivotModel;
+                    const { dirPath, basePath } = parseModelPath(pivotModelPath);
+                    return {
+                        loader: asLoader(new FilesystemDL({ dirPath })),
+                        modelName: basePath,
+                        diskPath: dirPath,
+                        config: {
+                            ...config,
+                            srcVocabPath: pivotSrcVocabPath,
+                            dstVocabPath: pivotDstVocabPath
+                        }
+                    };
+                })(),
+            }),
         }),
     };
     if (config.modelType === TranslationNmtcpp.ModelTypes.IndicTrans) {
@@ -53,10 +99,71 @@ function createNmtModel(modelId, modelPath, nmtConfig) {
 export const nmtPlugin = definePlugin({
     modelType: ModelType.nmtcppTranslation,
     displayName: "NMT (nmtcpp)",
-    addonPackage: "@qvac/translation-nmtcpp",
+    addonPackage: ADDON_NMT,
+    loadConfigSchema: nmtConfigBaseSchema,
+    async resolveConfig(cfg, ctx) {
+        const { srcVocabSrc, dstVocabSrc, ...nmtConfig } = cfg;
+        if (nmtConfig.engine !== "Bergamot") {
+            return { config: nmtConfig };
+        }
+        let srcSrc = srcVocabSrc;
+        let dstSrc = dstVocabSrc;
+        if (!srcSrc || !dstSrc) {
+            const derived = ctx.modelSrc.startsWith("pear://")
+                ? deriveBergamotVocabSources(ctx.modelSrc)
+                : ctx.modelSrc.startsWith("registry://")
+                    ? deriveBergamotRegistryVocabSources(ctx.modelSrc)
+                    : null;
+            if (derived) {
+                srcSrc = srcSrc ?? derived.srcVocabSrc;
+                dstSrc = dstSrc ?? derived.dstVocabSrc;
+            }
+        }
+        if (!srcSrc || !dstSrc) {
+            throw new ModelLoadFailedError("Bergamot requires srcVocabSrc and dstVocabSrc. Provide them in modelConfig or use a pear:// or registry:// model source for auto-derivation.");
+        }
+        const pivotModel = nmtConfig.pivotModel;
+        if (!pivotModel) {
+            const [srcVocabPath, dstVocabPath] = await Promise.all([
+                ctx.resolveModelPath(srcSrc),
+                ctx.resolveModelPath(dstSrc),
+            ]);
+            return {
+                config: nmtConfig,
+                artifacts: { srcVocabPath, dstVocabPath },
+            };
+        }
+        let pivotSrcSrc = pivotModel.srcVocabSrc;
+        let pivotDstSrc = pivotModel.dstVocabSrc;
+        if (!pivotSrcSrc || !pivotDstSrc) {
+            const pivotDerived = pivotModel.modelSrc.startsWith("pear://")
+                ? deriveBergamotVocabSources(pivotModel.modelSrc)
+                : pivotModel.modelSrc.startsWith("registry://")
+                    ? deriveBergamotRegistryVocabSources(pivotModel.modelSrc)
+                    : null;
+            if (pivotDerived) {
+                pivotSrcSrc = pivotSrcSrc ?? pivotDerived.srcVocabSrc;
+                pivotDstSrc = pivotDstSrc ?? pivotDerived.dstVocabSrc;
+            }
+        }
+        if (!pivotSrcSrc || !pivotDstSrc) {
+            throw new ModelLoadFailedError("Bergamot pivot model requires srcVocabSrc and dstVocabSrc. Provide them in modelConfig or use a pear:// or registry:// model source for auto-derivation.");
+        }
+        const [srcVocabPath, dstVocabPath, pivotSrcVocabPath, pivotDstVocabPath, pivotModelPath] = await Promise.all([
+            ctx.resolveModelPath(srcSrc),
+            ctx.resolveModelPath(dstSrc),
+            ctx.resolveModelPath(pivotSrcSrc),
+            ctx.resolveModelPath(pivotDstSrc),
+            ctx.resolveModelPath(pivotModel.modelSrc),
+        ]);
+        return {
+            config: nmtConfig,
+            artifacts: { srcVocabPath, dstVocabPath, pivotSrcVocabPath, pivotDstVocabPath, pivotModelPath },
+        };
+    },
     createModel(params) {
         const nmtConfig = (params.modelConfig ?? {});
-        const { model, loader } = createNmtModel(params.modelId, params.modelPath, nmtConfig);
+        const { model, loader } = createNmtModel(params.modelId, params.modelPath, nmtConfig, params.artifacts?.["srcVocabPath"], params.artifacts?.["dstVocabPath"], params.artifacts?.["pivotModelPath"], params.artifacts?.["pivotSrcVocabPath"], params.artifacts?.["pivotDstVocabPath"]);
         return { model, loader };
     },
     handlers: {
@@ -92,6 +199,6 @@ export const nmtPlugin = definePlugin({
     },
     logging: {
         module: nmtAddonLogging,
-        namespace: ADDON_NAMESPACES.NMTCPP,
+        namespace: ModelType.nmtcppTranslation,
     },
 });

package/dist/server/bare/plugins/onnx-ocr/plugin.d.ts

@@ -1,8 +1,56 @@
-import { type CreateModelParams, type PluginModelResult } from "../../../../schemas/index";
+import { type CreateModelParams, type PluginModelResult, type OCRConfig, type ResolveContext, type ResolveResult } from "../../../../schemas/index";
 export declare const ocrPlugin: {
     modelType: "onnx-ocr";
     displayName: string;
-    addonPackage: string;
+    addonPackage: "@qvac/ocr-onnx";
+    loadConfigSchema: import("zod").ZodObject<{
+        langList: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        useGPU: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        timeout: import("zod").ZodOptional<import("zod").ZodNumber>;
+        pipelineMode: import("zod").ZodOptional<import("zod").ZodEnum<{
+            easyocr: "easyocr";
+            doctr: "doctr";
+        }>>;
+        magRatio: import("zod").ZodOptional<import("zod").ZodNumber>;
+        defaultRotationAngles: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+        contrastRetry: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        lowConfidenceThreshold: import("zod").ZodOptional<import("zod").ZodNumber>;
+        recognizerBatchSize: import("zod").ZodOptional<import("zod").ZodNumber>;
+        decodingMethod: import("zod").ZodOptional<import("zod").ZodEnum<{
+            attention: "attention";
+            ctc: "ctc";
+        }>>;
+        straightenPages: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        detectorModelSrc: 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: OCRConfig, ctx: ResolveContext): Promise<ResolveResult<Record<string, unknown>, "detectorModelPath">>;
     createModel(params: CreateModelParams): PluginModelResult;
     handlers: {
         ocrStream: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{

package/dist/server/bare/plugins/onnx-ocr/plugin.js

@@ -1,19 +1,37 @@
-import { definePlugin, defineHandler, ocrStreamRequestSchema, ocrStreamResponseSchema, ModelType, } from "../../../../schemas/index.js";
-import { createStreamLogger } from "../../../../logging/index.js";
+import { definePlugin, defineHandler, ocrStreamRequestSchema, ocrStreamResponseSchema, ModelType, ocrConfigSchema, ADDON_OCR, } from "../../../../schemas/index.js";
+import { ModelLoadFailedError } from "../../../../utils/errors-server.js";
+import { hyperdriveUrlSchema } from "../../../../schemas/load-model.js";
+import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
 import { parseModelPath } from "../../../utils/index.js";
 import FilesystemDL from "@qvac/dl-filesystem";
 import { ONNXOcr } from "@qvac/ocr-onnx";
 import { ocr } from "./ops/ocr-stream.js";
+import { OCR_CRAFT_DETECTOR } from "../../../../models/registry/index.js";
+const OCR_DETECTOR_FILENAME = "detector_craft.onnx";
+function deriveDetectorSource(modelSrc) {
+    if (modelSrc.startsWith("pear://")) {
+        const { key } = hyperdriveUrlSchema.parse(modelSrc);
+        return `pear://${key}/${OCR_DETECTOR_FILENAME}`;
+    }
+    if (modelSrc.startsWith("registry://")) {
+        return OCR_CRAFT_DETECTOR.src;
+    }
+    return undefined;
+}
 function createOCRModel(modelId, detectorPath, recognizerPath, ocrConfig) {
     const { dirPath } = parseModelPath(detectorPath);
     const loader = new FilesystemDL({ dirPath });
-    const logger = createStreamLogger(modelId, "ocr");
+    const logger = createStreamLogger(modelId, ModelType.onnxOcr);
+    registerAddonLogger(modelId, ModelType.onnxOcr, logger);
     const params = {
         pathDetector: detectorPath,
         pathRecognizer: recognizerPath,
         langList: ocrConfig.langList || ["en"],
         useGPU: ocrConfig.useGPU ?? true,
         ...(ocrConfig.timeout !== undefined && { timeout: ocrConfig.timeout }),
+        ...(ocrConfig.pipelineMode !== undefined && {
+            pipelineMode: ocrConfig.pipelineMode,
+        }),
         ...(ocrConfig.magRatio !== undefined && { magRatio: ocrConfig.magRatio }),
         ...(ocrConfig.defaultRotationAngles !== undefined && {
             defaultRotationAngles: ocrConfig.defaultRotationAngles,
@@ -27,6 +45,12 @@ function createOCRModel(modelId, detectorPath, recognizerPath, ocrConfig) {
         ...(ocrConfig.recognizerBatchSize !== undefined && {
             recognizerBatchSize: ocrConfig.recognizerBatchSize,
         }),
+        ...(ocrConfig.decodingMethod !== undefined && {
+            decodingMethod: ocrConfig.decodingMethod,
+        }),
+        ...(ocrConfig.straightenPages !== undefined && {
+            straightenPages: ocrConfig.straightenPages,
+        }),
     };
     const args = {
         loader: loader,
@@ -41,10 +65,27 @@ function createOCRModel(modelId, detectorPath, recognizerPath, ocrConfig) {
 export const ocrPlugin = definePlugin({
     modelType: ModelType.onnxOcr,
     displayName: "OCR (ONNX)",
-    addonPackage: "@qvac/ocr-onnx",
+    addonPackage: ADDON_OCR,
+    loadConfigSchema: ocrConfigSchema,
+    async resolveConfig(cfg, ctx) {
+        const { detectorModelSrc, ...ocrConfig } = cfg;
+        const detectorSrc = detectorModelSrc ?? deriveDetectorSource(ctx.modelSrc);
+        if (!detectorSrc) {
+            throw new ModelLoadFailedError("Detector model required for OCR. Use a hyperdrive source or provide detectorModelSrc");
+        }
+        const detectorModelPath = await ctx.resolveModelPath(detectorSrc);
+        return {
+            config: ocrConfig,
+            artifacts: { detectorModelPath },
+        };
+    },
     createModel(params) {
         const ocrConfig = (params.modelConfig ?? {});
-        const { model, loader } = createOCRModel(params.modelId, params.artifacts?.["detectorModelPath"] ?? "", params.modelPath, // recognizerPath
+        const detectorModelPath = params.artifacts?.["detectorModelPath"];
+        if (!detectorModelPath) {
+            throw new ModelLoadFailedError("Detector model path missing. Ensure detectorModelSrc is provided in modelConfig.");
+        }
+        const { model, loader } = createOCRModel(params.modelId, detectorModelPath, params.modelPath, // recognizerPath
         ocrConfig);
         return { model, loader };
     },