@qvac/sdk 0.8.1 → 1.0.0

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

@@ -1,201 +0,0 @@
-import nmtAddonLogging from "@qvac/translation-nmtcpp/addonLogging.js";
-import TranslationNmtcpp, {} from "@qvac/translation-nmtcpp";
-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 { ModelLoadFailedError } from "../../../../utils/errors-server.js";
-import { asLoader } from "../../utils/loader-adapter.js";
-import { translate } from "../../ops/translate.js";
-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, 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),
-        logger,
-        modelName: basePath,
-        diskPath: dirPath,
-        params: {
-            mode,
-            srcLang: from,
-            dstLang: to,
-        },
-    };
-    const generationParams = {
-        beamsize,
-        lengthpenalty,
-        maxlength,
-        repetitionpenalty,
-        norepeatngramsize,
-        temperature,
-        topk,
-        topp,
-    };
-    const config = {
-        modelType: TranslationNmtcpp.ModelTypes[engine],
-        ...generationParams,
-        ...(nmtConfig.engine === "Bergamot" && {
-            ...(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
-                        }
-                    };
-                })(),
-            }),
-        }),
-    };
-    const model = new TranslationNmtcpp(args, config);
-    return { model, loader };
-}
-export const nmtPlugin = definePlugin({
-    modelType: ModelType.nmtcppTranslation,
-    displayName: "NMT (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, params.artifacts?.["srcVocabPath"], params.artifacts?.["dstVocabPath"], params.artifacts?.["pivotModelPath"], params.artifacts?.["pivotSrcVocabPath"], params.artifacts?.["pivotDstVocabPath"]);
-        return { model, loader };
-    },
-    handlers: {
-        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: nmtAddonLogging,
-        namespace: ModelType.nmtcppTranslation,
-    },
-});

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

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

package/dist/server/bare/plugins/onnx-ocr/ops/ocr-stream.js

@@ -1,110 +0,0 @@
-import { getModel } from "../../../registry/model-registry.js";
-import fs from "bare-fs";
-import path from "bare-path";
-import { getCacheDir } from "../../../../utils/index.js";
-import { ImageFileNotFoundError, InvalidImageInputError, } from "../../../../../utils/errors-server.js";
-function polygonToBbox(polygon) {
-    const xs = polygon.map((p) => p[0]);
-    const ys = polygon.map((p) => p[1]);
-    return [Math.min(...xs), Math.min(...ys), Math.max(...xs), Math.max(...ys)];
-}
-function normalizeBlock(block) {
-    if (block &&
-        typeof block === "object" &&
-        !Array.isArray(block) &&
-        "text" in block) {
-        const obj = block;
-        return {
-            text: obj.text || "",
-            ...(obj.bbox && { bbox: obj.bbox }),
-            ...(obj.confidence !== undefined && { confidence: obj.confidence }),
-        };
-    }
-    // Addon format: [polygon, text, confidence] where polygon is [[x1,y1], [x2,y2], [x3,y3], [x4,y4]]
-    if (Array.isArray(block) && block.length >= 2) {
-        const blockArr = block;
-        const [polygonOrBbox, text, confidence] = blockArr;
-        const textStr = typeof text === "string" ? text : "";
-        if (Array.isArray(polygonOrBbox) &&
-            polygonOrBbox.length === 4 &&
-            Array.isArray(polygonOrBbox[0]) &&
-            polygonOrBbox[0].length === 2) {
-            return {
-                text: textStr,
-                bbox: polygonToBbox(polygonOrBbox),
-                ...(confidence !== undefined && { confidence: Number(confidence) }),
-            };
-        }
-        if (Array.isArray(polygonOrBbox) &&
-            polygonOrBbox.length === 4 &&
-            typeof polygonOrBbox[0] === "number") {
-            return {
-                text: textStr,
-                bbox: polygonOrBbox,
-                ...(confidence !== undefined && { confidence: Number(confidence) }),
-            };
-        }
-    }
-    return null;
-}
-export async function* ocr(params) {
-    const model = getModel(params.modelId);
-    let imagePath;
-    let cleanupPath = null;
-    switch (params.image.type) {
-        case "base64": {
-            const tempDir = getCacheDir("tmp");
-            const suffix = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
-            const tempPath = path.join(tempDir, `ocr-${suffix}.png`);
-            fs.writeFileSync(tempPath, Buffer.from(params.image.value, "base64"));
-            imagePath = tempPath;
-            cleanupPath = tempPath;
-            break;
-        }
-        case "filePath": {
-            imagePath = params.image.value;
-            try {
-                fs.accessSync(imagePath);
-            }
-            catch (error) {
-                throw new ImageFileNotFoundError(imagePath, error);
-            }
-            break;
-        }
-        default:
-            throw new InvalidImageInputError();
-    }
-    try {
-        const response = (await model.run({
-            path: imagePath,
-            ...(params.options && { options: params.options }),
-        }));
-        const rawData = [];
-        await response
-            .onUpdate((data) => {
-            rawData.push(data);
-            return [];
-        })
-            .await();
-        const blocks = rawData
-            .flat(1)
-            .map(normalizeBlock)
-            .filter((b) => b !== null);
-        if (blocks.length > 0) {
-            yield { blocks };
-        }
-        if (response.stats) {
-            yield { blocks: [], stats: response.stats };
-        }
-    }
-    finally {
-        if (cleanupPath) {
-            try {
-                fs.unlinkSync(cleanupPath);
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
-    }
-}

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

@@ -1,86 +0,0 @@
-import { type CreateModelParams, type PluginModelResult, type OCRConfig, type ResolveContext, type ResolveResult } from "../../../../schemas/index";
-export declare const ocrPlugin: {
-    modelType: "onnx-ocr";
-    displayName: 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<{
-            modelId: import("zod").ZodString;
-            image: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-                type: import("zod").ZodLiteral<"base64">;
-                value: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-                type: import("zod").ZodLiteral<"filePath">;
-                value: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>], "type">;
-            options: import("zod").ZodOptional<import("zod").ZodObject<{
-                paragraph: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            }, import("zod/v4/core").$strip>>;
-            type: import("zod").ZodLiteral<"ocrStream">;
-        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-            type: import("zod").ZodLiteral<"ocrStream">;
-            blocks: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-                text: import("zod").ZodString;
-                bbox: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
-                confidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>>>;
-            done: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            error: import("zod").ZodOptional<import("zod").ZodString>;
-            stats: import("zod").ZodOptional<import("zod").ZodObject<{
-                detectionTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                recognitionTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                totalTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>>;
-        }, import("zod/v4/core").$strip>>;
-    };
-};
-//# sourceMappingURL=plugin.d.ts.map

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

@@ -1,117 +0,0 @@
-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, 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,
-        }),
-        ...(ocrConfig.contrastRetry !== undefined && {
-            contrastRetry: ocrConfig.contrastRetry,
-        }),
-        ...(ocrConfig.lowConfidenceThreshold !== undefined && {
-            lowConfidenceThreshold: ocrConfig.lowConfidenceThreshold,
-        }),
-        ...(ocrConfig.recognizerBatchSize !== undefined && {
-            recognizerBatchSize: ocrConfig.recognizerBatchSize,
-        }),
-        ...(ocrConfig.decodingMethod !== undefined && {
-            decodingMethod: ocrConfig.decodingMethod,
-        }),
-        ...(ocrConfig.straightenPages !== undefined && {
-            straightenPages: ocrConfig.straightenPages,
-        }),
-    };
-    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 };
-}
-export const ocrPlugin = definePlugin({
-    modelType: ModelType.onnxOcr,
-    displayName: "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 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 };
-    },
-    handlers: {
-        ocrStream: defineHandler({
-            requestSchema: ocrStreamRequestSchema,
-            responseSchema: ocrStreamResponseSchema,
-            streaming: true,
-            handler: async function* (request) {
-                for await (const result of ocr({
-                    modelId: request.modelId,
-                    image: request.image,
-                    options: request.options,
-                })) {
-                    yield {
-                        type: "ocrStream",
-                        blocks: result.blocks,
-                        ...(result.stats && { stats: result.stats }),
-                    };
-                }
-                yield {
-                    type: "ocrStream",
-                    blocks: [],
-                    done: true,
-                };
-            },
-        }),
-    },
-});