@qvac/sdk 0.6.1 → 0.7.1

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

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

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

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

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

@@ -0,0 +1,24 @@
+import { type CreateModelParams, type PluginModelResult } from "../../../../schemas/index";
+export declare const embeddingsPlugin: {
+    modelType: "llamacpp-embedding";
+    displayName: string;
+    addonPackage: string;
+    createModel(params: CreateModelParams): PluginModelResult;
+    handlers: {
+        embed: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
+            modelId: import("zod").ZodString;
+            text: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>;
+            type: import("zod").ZodLiteral<"embed">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"embed">;
+            success: import("zod").ZodBoolean;
+            embedding: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodArray<import("zod").ZodNumber>, import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodNumber>>]>>;
+            error: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    };
+    logging: {
+        module: import("@qvac/embed-llamacpp/addonLogging").AddonLogging;
+        namespace: "llamacpp:embed";
+    };
+};
+//# sourceMappingURL=plugin.d.ts.map

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

@@ -0,0 +1,73 @@
+import EmbedLlamacpp, {} from "@qvac/embed-llamacpp";
+import embedAddonLogging from "@qvac/embed-llamacpp/addonLogging.js";
+import { definePlugin, defineHandler, embedRequestSchema, embedResponseSchema, ModelType, } from "../../../../schemas/index.js";
+import { ADDON_NAMESPACES, createStreamLogger, registerAddonLogger, } from "../../../../logging/index.js";
+import { parseModelPath } from "../../../utils/index.js";
+import FilesystemDL from "@qvac/dl-filesystem";
+import { asLoader } from "../../utils/loader-adapter.js";
+import { embed } from "../../ops/embed.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");
+}
+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 };
+}
+export const embeddingsPlugin = definePlugin({
+    modelType: ModelType.llamacppEmbedding,
+    displayName: "Embeddings (llama.cpp)",
+    addonPackage: "@qvac/embed-llamacpp",
+    createModel(params) {
+        const embedConfig = (params.modelConfig ?? {});
+        const { model, loader } = createEmbeddingsModel(params.modelId, params.modelPath, embedConfig);
+        return { model, loader };
+    },
+    handlers: {
+        embed: defineHandler({
+            requestSchema: embedRequestSchema,
+            responseSchema: embedResponseSchema,
+            streaming: false,
+            handler: async function (request) {
+                const embedding = await embed({
+                    modelId: request.modelId,
+                    text: request.text,
+                });
+                return {
+                    type: "embed",
+                    success: true,
+                    embedding,
+                };
+            },
+        }),
+    },
+    logging: {
+        module: embedAddonLogging,
+        namespace: ADDON_NAMESPACES.LLAMACPP_EMBED,
+    },
+});

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

@@ -0,0 +1,45 @@
+import { type CreateModelParams, type PluginModelResult } from "../../../../schemas/index";
+export declare const nmtPlugin: {
+    modelType: "nmtcpp-translation";
+    displayName: string;
+    addonPackage: string;
+    createModel(params: CreateModelParams): PluginModelResult;
+    handlers: {
+        translate: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            modelId: import("zod").ZodString;
+            text: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>;
+            stream: import("zod").ZodBoolean;
+            modelType: import("zod").ZodEnum<{
+                "nmtcpp-translation": "nmtcpp-translation";
+                nmt: "nmt";
+            }>;
+            type: import("zod").ZodLiteral<"translate">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            modelId: import("zod").ZodString;
+            text: import("zod").ZodString;
+            stream: import("zod").ZodBoolean;
+            modelType: import("zod").ZodEnum<{
+                "llamacpp-completion": "llamacpp-completion";
+                llm: "llm";
+            }>;
+            from: import("zod").ZodOptional<import("zod").ZodString>;
+            to: import("zod").ZodString;
+            context: import("zod").ZodOptional<import("zod").ZodString>;
+            type: import("zod").ZodLiteral<"translate">;
+        }, import("zod/v4/core").$strip>]>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"translate">;
+            token: import("zod").ZodString;
+            done: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            stats: import("zod").ZodOptional<import("zod").ZodObject<{
+                processedTokens: import("zod").ZodNumber;
+                processingTime: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
+            error: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    };
+    logging: {
+        module: import("@qvac/translation-nmtcpp/addonLogging").AddonLogging;
+        namespace: "nmtcpp";
+    };
+};
+//# sourceMappingURL=plugin.d.ts.map

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

@@ -0,0 +1,97 @@
+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 { 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";
+import { translate } from "../../ops/translate.js";
+function createNmtModel(modelId, modelPath, nmtConfig) {
+    const { dirPath, basePath } = parseModelPath(modelPath);
+    const loader = new FilesystemDL({ dirPath });
+    const logger = createStreamLogger(modelId, "nmtcpp");
+    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" && {
+            ...(nmtConfig.srcVocabPath && { srcVocabPath: nmtConfig.srcVocabPath }),
+            ...(nmtConfig.dstVocabPath && { dstVocabPath: nmtConfig.dstVocabPath }),
+            ...(nmtConfig.normalize !== undefined && {
+                normalize: nmtConfig.normalize,
+            }),
+        }),
+    };
+    if (config.modelType === TranslationNmtcpp.ModelTypes.IndicTrans) {
+        throw new TranslationFailedError("IndicTrans models are not supported with current NMT addon version.");
+    }
+    const model = new TranslationNmtcpp(args, config);
+    return { model, loader };
+}
+export const nmtPlugin = definePlugin({
+    modelType: ModelType.nmtcppTranslation,
+    displayName: "NMT (nmtcpp)",
+    addonPackage: "@qvac/translation-nmtcpp",
+    createModel(params) {
+        const nmtConfig = (params.modelConfig ?? {});
+        const { model, loader } = createNmtModel(params.modelId, params.modelPath, nmtConfig);
+        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: ADDON_NAMESPACES.NMTCPP,
+    },
+});

package/dist/server/bare/{addons/onnx-ocr/handlers → plugins/onnx-ocr/ops}/ocr-stream.js

@@ -54,7 +54,8 @@ export async function* ocr(params) {
     switch (params.image.type) {
         case "base64": {
             const tempDir = getCacheDir("tmp");
-            const tempPath = path.join(tempDir, `ocr-${Date.now()}.png`);
+            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;

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

@@ -0,0 +1,38 @@
+import { type CreateModelParams, type PluginModelResult } from "../../../../schemas/index";
+export declare const ocrPlugin: {
+    modelType: "onnx-ocr";
+    displayName: string;
+    addonPackage: string;
+    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/{addons/onnx-ocr/create-model.js → plugins/onnx-ocr/plugin.js}

@@ -1,9 +1,10 @@
-import {} from "../../registry/model-registry.js";
+import { definePlugin, defineHandler, ocrStreamRequestSchema, ocrStreamResponseSchema, ModelType, } from "../../../../schemas/index.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) {
+import { ocr } from "./ops/ocr-stream.js";
+function createOCRModel(modelId, detectorPath, recognizerPath, ocrConfig) {
     const { dirPath } = parseModelPath(detectorPath);
     const loader = new FilesystemDL({ dirPath });
     const logger = createStreamLogger(modelId, "ocr");
@@ -37,3 +38,39 @@ export function createOCRModel(modelId, detectorPath, recognizerPath, ocrConfig)
     const model = new ONNXOcr(args);
     return { model, loader };
 }
+export const ocrPlugin = definePlugin({
+    modelType: ModelType.onnxOcr,
+    displayName: "OCR (ONNX)",
+    addonPackage: "@qvac/ocr-onnx",
+    createModel(params) {
+        const ocrConfig = (params.modelConfig ?? {});
+        const { model, loader } = createOCRModel(params.modelId, params.artifacts?.["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,
+                };
+            },
+        }),
+    },
+});

package/dist/server/bare/{addons/onnx-tts/handlers → plugins/onnx-tts/ops}/text-to-speech.js

@@ -22,7 +22,9 @@ export async function* textToSpeech(params) {
         // Streaming mode: use async iterator pattern
         const outputQueue = [];
         let isComplete = false;
+        let streamError = null;
         let resolveNext = null;
+        let rejectNext = null;
         // Start the response processing
         const responsePromise = response
             .onUpdate((data) => {
@@ -37,6 +39,7 @@ export async function* textToSpeech(params) {
                     done: false,
                 });
                 resolveNext = null;
+                rejectNext = null;
             }
             else {
                 // Otherwise, queue the output
@@ -49,11 +52,29 @@ export async function* textToSpeech(params) {
             if (resolveNext) {
                 resolveNext({ value: undefined, done: true });
                 resolveNext = null;
+                rejectNext = null;
+            }
+        })
+            .catch((err) => {
+            streamError = err;
+            isComplete = true;
+            if (rejectNext) {
+                rejectNext(err);
+                resolveNext = null;
+                rejectNext = null;
             }
         });
         // Create an async iterator
         const asyncIterator = {
             async next() {
+                if (streamError) {
+                    if (streamError instanceof Error)
+                        throw streamError;
+                    const message = typeof streamError === "string"
+                        ? streamError
+                        : JSON.stringify(streamError);
+                    throw new Error(message);
+                }
                 if (outputQueue.length > 0) {
                     const data = outputQueue.shift();
                     return {
@@ -69,8 +90,9 @@ export async function* textToSpeech(params) {
                     return { value: undefined, done: true };
                 }
                 // Wait for the next output
-                return new Promise((resolve) => {
+                return new Promise((resolve, reject) => {
                     resolveNext = resolve;
+                    rejectNext = reject;
                 });
             },
             [Symbol.asyncIterator]() {