@qvac/sdk 0.18.2 → 0.19.0

package/dist/server/bare/plugins/bci-whispercpp-transcription/plugin.d.ts

@@ -1,174 +0,0 @@
-import bciAddonLogging from '@qvac/bci-whispercpp/addonLogging';
-import { type CreateModelParams, type PluginModelResult } from '../../../../schemas/index.js';
-import { resolveBciConfig } from '../../../../server/bare/plugins/bci-whispercpp-transcription/resolve-config.js';
-export declare const bciPlugin: {
-    modelType: "bci-whispercpp-transcription";
-    displayName: string;
-    addonPackage: "@qvac/bci-whispercpp";
-    loadConfigSchema: import("zod").ZodObject<{
-        whisperConfig: import("zod").ZodOptional<import("zod").ZodObject<{
-            language: import("zod").ZodOptional<import("zod").ZodString>;
-            n_threads: import("zod").ZodOptional<import("zod").ZodNumber>;
-            temperature: import("zod").ZodOptional<import("zod").ZodNumber>;
-            suppress_nst: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            suppress_blank: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            duration_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
-            translate: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            no_timestamps: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            single_segment: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            print_special: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            print_progress: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            print_realtime: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            print_timestamps: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            detect_language: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            greedy_best_of: import("zod").ZodOptional<import("zod").ZodNumber>;
-            beam_search_beam_size: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>>;
-        bciConfig: import("zod").ZodOptional<import("zod").ZodObject<{
-            day_idx: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>>;
-        contextParams: import("zod").ZodOptional<import("zod").ZodObject<{
-            model: import("zod").ZodOptional<import("zod").ZodString>;
-            use_gpu: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            flash_attn: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            gpu_device: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>>;
-        miscConfig: import("zod").ZodOptional<import("zod").ZodObject<{
-            caption_enabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        }, import("zod/v4/core").$strip>>;
-        backendsDir: import("zod").ZodOptional<import("zod").ZodString>;
-        embedderModelSrc: 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<{
-                embeddings: "embeddings";
-                diffusion: "diffusion";
-                audiogen: "audiogen";
-                tts: "tts";
-                ocr: "ocr";
-                vla: "vla";
-                "llamacpp-completion": "llamacpp-completion";
-                "whispercpp-transcription": "whispercpp-transcription";
-                "bci-whispercpp-transcription": "bci-whispercpp-transcription";
-                "llamacpp-embedding": "llamacpp-embedding";
-                "nmtcpp-translation": "nmtcpp-translation";
-                "onnx-tts": "onnx-tts";
-                "tts-ggml": "tts-ggml";
-                "parakeet-transcription": "parakeet-transcription";
-                "ggml-ocr": "ggml-ocr";
-                "sdcpp-generation": "sdcpp-generation";
-                "audiogen-ggml": "audiogen-ggml";
-                "ggml-vla": "ggml-vla";
-                "ggml-classification": "ggml-classification";
-                llm: "llm";
-                whisper: "whisper";
-                bci: "bci";
-                nmt: "nmt";
-                parakeet: "parakeet";
-                classification: "classification";
-            }>, import("zod").ZodLiteral<"vad">]>>;
-        }, import("zod/v4/core").$strip>]>>;
-    }, import("zod/v4/core").$strip>;
-    resolveConfig: typeof resolveBciConfig;
-    createModel(params: CreateModelParams): PluginModelResult;
-    handlers: {
-        bciTranscribe: import("../../../../schemas/index.js").PluginHandlerDefinition<import("zod").ZodObject<{
-            modelId: import("zod").ZodString;
-            metadata: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            neuralData: 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">;
-            type: import("zod").ZodLiteral<"bciTranscribe">;
-            requestId: import("zod").ZodOptional<import("zod").ZodString>;
-        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-            text: import("zod").ZodOptional<import("zod").ZodString>;
-            done: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            stats: import("zod").ZodOptional<import("zod").ZodObject<{
-                audioDuration: import("zod").ZodOptional<import("zod").ZodNumber>;
-                realTimeFactor: import("zod").ZodOptional<import("zod").ZodNumber>;
-                tokensPerSecond: import("zod").ZodOptional<import("zod").ZodNumber>;
-                totalTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
-                totalSegments: import("zod").ZodOptional<import("zod").ZodNumber>;
-                whisperEncodeTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                whisperDecodeTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                encoderTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                decoderTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                melSpecTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                backendDevice: import("zod").ZodOptional<import("zod").ZodNumber>;
-                backendId: import("zod").ZodOptional<import("zod").ZodNumber>;
-                gpuUnsupported: import("zod").ZodOptional<import("zod").ZodNumber>;
-                gpuMemTotalMb: import("zod").ZodOptional<import("zod").ZodNumber>;
-                gpuMemFreeMb: import("zod").ZodOptional<import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>>;
-            error: import("zod").ZodOptional<import("zod").ZodString>;
-            segment: import("zod").ZodOptional<import("zod").ZodObject<{
-                text: import("zod").ZodString;
-                startMs: import("zod").ZodNumber;
-                endMs: import("zod").ZodNumber;
-                append: import("zod").ZodBoolean;
-                id: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>>;
-            type: import("zod").ZodLiteral<"bciTranscribe">;
-        }, import("zod/v4/core").$strip>>;
-        bciTranscribeStream: import("../../../../schemas/index.js").PluginHandlerDefinition<import("zod").ZodObject<{
-            modelId: import("zod").ZodString;
-            metadata: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            type: import("zod").ZodLiteral<"bciTranscribeStream">;
-            streamOpts: import("zod").ZodOptional<import("zod").ZodObject<{
-                windowTimesteps: import("zod").ZodOptional<import("zod").ZodNumber>;
-                hopTimesteps: import("zod").ZodOptional<import("zod").ZodNumber>;
-                emit: import("zod").ZodOptional<import("zod").ZodEnum<{
-                    full: "full";
-                    delta: "delta";
-                }>>;
-            }, import("zod/v4/core").$strip>>;
-            requestId: import("zod").ZodOptional<import("zod").ZodString>;
-        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-            text: import("zod").ZodOptional<import("zod").ZodString>;
-            done: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            stats: import("zod").ZodOptional<import("zod").ZodObject<{
-                audioDuration: import("zod").ZodOptional<import("zod").ZodNumber>;
-                realTimeFactor: import("zod").ZodOptional<import("zod").ZodNumber>;
-                tokensPerSecond: import("zod").ZodOptional<import("zod").ZodNumber>;
-                totalTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
-                totalSegments: import("zod").ZodOptional<import("zod").ZodNumber>;
-                whisperEncodeTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                whisperDecodeTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                encoderTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                decoderTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                melSpecTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                backendDevice: import("zod").ZodOptional<import("zod").ZodNumber>;
-                backendId: import("zod").ZodOptional<import("zod").ZodNumber>;
-                gpuUnsupported: import("zod").ZodOptional<import("zod").ZodNumber>;
-                gpuMemTotalMb: import("zod").ZodOptional<import("zod").ZodNumber>;
-                gpuMemFreeMb: import("zod").ZodOptional<import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>>;
-            error: import("zod").ZodOptional<import("zod").ZodString>;
-            segment: import("zod").ZodOptional<import("zod").ZodObject<{
-                text: import("zod").ZodString;
-                startMs: import("zod").ZodNumber;
-                endMs: import("zod").ZodNumber;
-                append: import("zod").ZodBoolean;
-                id: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>>;
-            type: import("zod").ZodLiteral<"bciTranscribeStream">;
-        }, import("zod/v4/core").$strip>>;
-    };
-    logging: {
-        module: typeof bciAddonLogging;
-        namespace: "bci-whispercpp-transcription";
-    };
-};
-//# sourceMappingURL=plugin.d.ts.map

package/dist/server/bare/plugins/bci-whispercpp-transcription/plugin.js

@@ -1,111 +0,0 @@
-import bciAddonLogging from '@qvac/bci-whispercpp/addonLogging';
-import BCIWhispercpp, {} from '@qvac/bci-whispercpp';
-import { definePlugin, defineHandler, defineDuplexHandler, bciTranscribeRequestSchema, bciTranscribeResponseSchema, bciTranscribeStreamRequestSchema, bciTranscribeStreamResponseSchema, ModelType, bciConfigSchema, ADDON_BCI } from '../../../../schemas/index.js';
-import { createStreamLogger, registerAddonLogger } from '../../../../logging/index.js';
-import { bciTranscribe, bciTranscribeStream } from '../../../../server/bare/ops/bci-transcribe.js';
-import { attachModelExecutionMs } from '../../../../profiling/model-execution.js';
-import { buildBciWhispercppArgs } from '../../../../server/bare/plugins/bci-whispercpp-transcription/args.js';
-import { resolveBciConfig } from '../../../../server/bare/plugins/bci-whispercpp-transcription/resolve-config.js';
-function createBciModel(modelId, modelPath, bciConfig, embedderPath) {
-    const logger = createStreamLogger(modelId, ModelType.bciWhispercppTranscription);
-    registerAddonLogger(modelId, ModelType.bciWhispercppTranscription, logger);
-    const args = buildBciWhispercppArgs(modelPath, embedderPath, logger);
-    const model = new BCIWhispercpp(args, bciConfig);
-    return { model };
-}
-export const bciPlugin = definePlugin({
-    modelType: ModelType.bciWhispercppTranscription,
-    displayName: 'BCI (whisper.cpp)',
-    addonPackage: ADDON_BCI,
-    loadConfigSchema: bciConfigSchema,
-    resolveConfig: resolveBciConfig,
-    createModel(params) {
-        const bciConfig = (params.modelConfig ?? {});
-        const { model } = createBciModel(params.modelId, params.modelPath, bciConfig, params.artifacts?.['embedderPath'] ?? '');
-        return { model };
-    },
-    handlers: {
-        bciTranscribe: defineHandler({
-            requestSchema: bciTranscribeRequestSchema,
-            responseSchema: bciTranscribeResponseSchema,
-            streaming: true,
-            // The BCI addon exposes a model-wide hard cancel — the running
-            // neural-signal job is interrupted on `cancel()`.
-            cancel: { scope: 'model', hard: true },
-            handler: async function* (request) {
-                const metadata = request.metadata === true;
-                const stream = metadata
-                    ? bciTranscribe({
-                        modelId: request.modelId,
-                        neuralData: request.neuralData,
-                        metadata: true
-                    }, request.requestId)
-                    : bciTranscribe({
-                        modelId: request.modelId,
-                        neuralData: request.neuralData
-                    }, request.requestId);
-                try {
-                    let result = await stream.next();
-                    while (!result.done) {
-                        yield metadata
-                            ? {
-                                type: 'bciTranscribe',
-                                segment: result.value
-                            }
-                            : {
-                                type: 'bciTranscribe',
-                                text: result.value
-                            };
-                        result = await stream.next();
-                    }
-                    const { modelExecutionMs, stats } = result.value;
-                    yield attachModelExecutionMs({
-                        type: 'bciTranscribe',
-                        text: '',
-                        done: true,
-                        ...(stats && { stats })
-                    }, modelExecutionMs);
-                }
-                finally {
-                    await stream.return?.(undefined);
-                }
-            }
-        }),
-        bciTranscribeStream: defineDuplexHandler({
-            requestSchema: bciTranscribeStreamRequestSchema,
-            responseSchema: bciTranscribeStreamResponseSchema,
-            streaming: true,
-            duplex: true,
-            // Same model-wide hard cancel surface as `bciTranscribe` — the BCI
-            // addon's `cancel()` tears down the active stream and interrupts the
-            // running window job.
-            cancel: { scope: 'model', hard: true },
-            handler: async function* (request, inputStream) {
-                const metadata = request.metadata === true;
-                const iterator = metadata
-                    ? bciTranscribeStream(request.modelId, inputStream, true, request.streamOpts, request.requestId)
-                    : bciTranscribeStream(request.modelId, inputStream, false, request.streamOpts, request.requestId);
-                for await (const value of iterator) {
-                    yield metadata
-                        ? {
-                            type: 'bciTranscribeStream',
-                            segment: value
-                        }
-                        : {
-                            type: 'bciTranscribeStream',
-                            text: value
-                        };
-                }
-                yield {
-                    type: 'bciTranscribeStream',
-                    text: '',
-                    done: true
-                };
-            }
-        })
-    },
-    logging: {
-        module: bciAddonLogging,
-        namespace: ModelType.bciWhispercppTranscription
-    }
-});

package/dist/server/bare/plugins/bci-whispercpp-transcription/resolve-config.d.ts

@@ -1,75 +0,0 @@
-import type { BciConfig, ResolveContext } from '../../../../schemas/index.js';
-export declare function resolveBciConfig(cfg: BciConfig, ctx: ResolveContext): Promise<{
-    config: {
-        whisperConfig?: {
-            language?: string | undefined;
-            n_threads?: number | undefined;
-            temperature?: number | undefined;
-            suppress_nst?: boolean | undefined;
-            suppress_blank?: boolean | undefined;
-            duration_ms?: number | undefined;
-            translate?: boolean | undefined;
-            no_timestamps?: boolean | undefined;
-            single_segment?: boolean | undefined;
-            print_special?: boolean | undefined;
-            print_progress?: boolean | undefined;
-            print_realtime?: boolean | undefined;
-            print_timestamps?: boolean | undefined;
-            detect_language?: boolean | undefined;
-            greedy_best_of?: number | undefined;
-            beam_search_beam_size?: number | undefined;
-        } | undefined;
-        bciConfig?: {
-            day_idx?: number | undefined;
-        } | undefined;
-        contextParams?: {
-            model?: string | undefined;
-            use_gpu?: boolean | undefined;
-            flash_attn?: boolean | undefined;
-            gpu_device?: number | undefined;
-        } | undefined;
-        miscConfig?: {
-            caption_enabled?: boolean | undefined;
-        } | undefined;
-        backendsDir?: string | undefined;
-    };
-    artifacts?: never;
-} | {
-    config: {
-        whisperConfig?: {
-            language?: string | undefined;
-            n_threads?: number | undefined;
-            temperature?: number | undefined;
-            suppress_nst?: boolean | undefined;
-            suppress_blank?: boolean | undefined;
-            duration_ms?: number | undefined;
-            translate?: boolean | undefined;
-            no_timestamps?: boolean | undefined;
-            single_segment?: boolean | undefined;
-            print_special?: boolean | undefined;
-            print_progress?: boolean | undefined;
-            print_realtime?: boolean | undefined;
-            print_timestamps?: boolean | undefined;
-            detect_language?: boolean | undefined;
-            greedy_best_of?: number | undefined;
-            beam_search_beam_size?: number | undefined;
-        } | undefined;
-        bciConfig?: {
-            day_idx?: number | undefined;
-        } | undefined;
-        contextParams?: {
-            model?: string | undefined;
-            use_gpu?: boolean | undefined;
-            flash_attn?: boolean | undefined;
-            gpu_device?: number | undefined;
-        } | undefined;
-        miscConfig?: {
-            caption_enabled?: boolean | undefined;
-        } | undefined;
-        backendsDir?: string | undefined;
-    };
-    artifacts: {
-        embedderPath: string;
-    };
-}>;
-//# sourceMappingURL=resolve-config.d.ts.map

package/dist/server/bare/plugins/bci-whispercpp-transcription/resolve-config.js

@@ -1,11 +0,0 @@
-export async function resolveBciConfig(cfg, ctx) {
-    const { embedderModelSrc, ...bciConfig } = cfg;
-    if (!embedderModelSrc) {
-        return { config: bciConfig };
-    }
-    const embedderPath = await ctx.resolveModelPath(embedderModelSrc);
-    return {
-        config: bciConfig,
-        artifacts: { embedderPath }
-    };
-}

package/dist/server/bare/plugins/ggml-classification/ops/classify.d.ts

@@ -1,6 +0,0 @@
-import { type ClassifyRequest, type ClassificationResult } from '../../../../../schemas/index.js';
-export declare function classify(params: ClassifyRequest): Promise<{
-    results: ClassificationResult[];
-    modelExecutionMs: number;
-}>;
-//# sourceMappingURL=classify.d.ts.map

package/dist/server/bare/plugins/ggml-classification/ops/classify.js

@@ -1,30 +0,0 @@
-import { getModel } from '../../../../../server/bare/registry/model-registry.js';
-import { classifyRequestSchema } from '../../../../../schemas/index.js';
-import { nowMs } from '../../../../../profiling/index.js';
-function hasClassify(model) {
-    return (typeof model === 'object' &&
-        model !== null &&
-        'classify' in model &&
-        typeof model.classify === 'function');
-}
-export async function classify(params) {
-    const { modelId, image, topK, width, height, channels } = classifyRequestSchema.parse(params);
-    const model = getModel(modelId);
-    if (!hasClassify(model)) {
-        throw new Error('Loaded model does not support classify()');
-    }
-    const imageBytes = Buffer.from(image, 'base64');
-    const opts = {};
-    if (topK !== undefined)
-        opts.topK = topK;
-    if (width !== undefined)
-        opts.width = width;
-    if (height !== undefined)
-        opts.height = height;
-    if (channels !== undefined)
-        opts.channels = channels;
-    const modelStart = nowMs();
-    const results = await model.classify(imageBytes, opts);
-    const modelExecutionMs = nowMs() - modelStart;
-    return { results, modelExecutionMs };
-}

package/dist/server/bare/plugins/ggml-classification/plugin.d.ts

@@ -1,32 +0,0 @@
-import { type CreateModelParams, type PluginModelResult } from '../../../../schemas/index.js';
-export declare const classificationPlugin: {
-    modelType: "ggml-classification";
-    displayName: string;
-    addonPackage: "@qvac/classification-ggml";
-    loadConfigSchema: import("zod").ZodObject<{
-        modelPath: import("zod").ZodOptional<import("zod").ZodString>;
-        topK: import("zod").ZodOptional<import("zod").ZodNumber>;
-        nativeLogger: import("zod").ZodOptional<import("zod").ZodBoolean>;
-    }, import("zod/v4/core").$strip>;
-    skipPrimaryModelPathValidation: true;
-    createModel(params: CreateModelParams): PluginModelResult;
-    handlers: {
-        classify: import("../../../../schemas/index.js").PluginHandlerDefinition<import("zod").ZodObject<{
-            modelId: import("zod").ZodString;
-            image: import("zod").ZodString;
-            topK: import("zod").ZodOptional<import("zod").ZodNumber>;
-            width: import("zod").ZodOptional<import("zod").ZodNumber>;
-            height: import("zod").ZodOptional<import("zod").ZodNumber>;
-            channels: import("zod").ZodOptional<import("zod").ZodLiteral<3>>;
-            type: import("zod").ZodLiteral<"classify">;
-        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-            type: import("zod").ZodLiteral<"classify">;
-            results: import("zod").ZodArray<import("zod").ZodObject<{
-                label: import("zod").ZodString;
-                confidence: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>>;
-            done: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        }, import("zod/v4/core").$strip>>;
-    };
-};
-//# sourceMappingURL=plugin.d.ts.map

package/dist/server/bare/plugins/ggml-classification/plugin.js

@@ -1,55 +0,0 @@
-import ImageClassifier from '@qvac/classification-ggml';
-import { definePlugin, defineHandler, classifyRequestSchema, classifyResponseSchema, ModelType, classificationConfigSchema, ADDON_CLASSIFICATION } from '../../../../schemas/index.js';
-import { createStreamLogger, registerAddonLogger } from '../../../../logging/index.js';
-import { classify } from '../../../../server/bare/plugins/ggml-classification/ops/classify.js';
-export const classificationPlugin = definePlugin({
-    modelType: ModelType.ggmlClassification,
-    displayName: 'Image Classification (GGML)',
-    addonPackage: ADDON_CLASSIFICATION,
-    loadConfigSchema: classificationConfigSchema,
-    skipPrimaryModelPathValidation: true,
-    createModel(params) {
-        const config = (params.modelConfig ?? {});
-        const resolvedModelPath = config.modelPath ?? (params.modelPath || undefined);
-        const logger = createStreamLogger(params.modelId, ModelType.ggmlClassification);
-        registerAddonLogger(params.modelId, ModelType.ggmlClassification, logger);
-        const inner = new ImageClassifier({
-            ...(resolvedModelPath ? { modelPath: resolvedModelPath } : {}),
-            logger,
-            nativeLogger: config.nativeLogger ?? false
-        });
-        // Apply the load-time `topK` as a default for classify() calls so the
-        // load-config field is not silently ignored. Per-request `topK` (passed
-        // in the second arg) wins via the `...opts` spread.
-        const defaultTopK = config.topK;
-        const model = {
-            load: () => inner.load(),
-            classify: (image, opts = {}) => inner.classify(image, {
-                ...(defaultTopK !== undefined && { topK: defaultTopK }),
-                ...opts
-            }),
-            unload: () => inner.unload()
-        };
-        return { model };
-    },
-    handlers: {
-        classify: defineHandler({
-            requestSchema: classifyRequestSchema,
-            responseSchema: classifyResponseSchema,
-            streaming: true,
-            // Classification is a single forward pass with no addon-side cancel
-            // surface — mirrors `ocr`/`tts`/`upscale`. The yield-once handler
-            // can't be interrupted partway, so we declare scope:"none".
-            cancel: { scope: 'none' },
-            handler: async function* (request) {
-                const { results, modelExecutionMs } = await classify(request);
-                yield {
-                    type: 'classify',
-                    results,
-                    done: true,
-                    modelExecutionMs
-                };
-            }
-        })
-    }
-});

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

@@ -1,8 +0,0 @@
-import { type OCRParams, type OCRTextBlock, type OCRStats } from '../../../../../schemas/index.js';
-export declare function ocr(params: OCRParams): AsyncGenerator<{
-    blocks: OCRTextBlock[];
-}, {
-    modelExecutionMs: number;
-    stats?: OCRStats;
-}, void>;
-//# sourceMappingURL=ocr-stream.d.ts.map

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

@@ -1,119 +0,0 @@
-import { getModel } from '../../../../../server/bare/registry/model-registry.js';
-import fs from 'bare-fs';
-import path from 'bare-path';
-import {} from '../../../../../schemas/index.js';
-import { buildStreamResult, hasDefinedValues } from '../../../../../profiling/model-execution.js';
-import { getCacheDir } from '../../../../../server/utils/index.js';
-import { ImageFileNotFoundError, InvalidImageInputError } from '../../../../../utils/errors-server.js';
-import { nowMs } from '../../../../../profiling/index.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 modelStart = nowMs();
-        const response = (await model.run({
-            path: imagePath,
-            ...(params.options && { options: params.options })
-        }));
-        const rawData = [];
-        await response
-            .onUpdate((data) => {
-            rawData.push(data);
-            return [];
-        })
-            .await();
-        const modelExecutionMs = nowMs() - modelStart;
-        const blocks = rawData
-            .flat(1)
-            .map(normalizeBlock)
-            .filter((b) => b !== null);
-        if (blocks.length > 0) {
-            yield { blocks };
-        }
-        const stats = {
-            ...(response.stats?.detectionTime !== undefined && {
-                detectionTime: response.stats.detectionTime
-            }),
-            ...(response.stats?.recognitionTime !== undefined && {
-                recognitionTime: response.stats.recognitionTime
-            }),
-            ...(response.stats?.totalTime !== undefined && { totalTime: response.stats.totalTime })
-        };
-        return buildStreamResult(modelExecutionMs, hasDefinedValues(stats) ? stats : undefined);
-    }
-    finally {
-        if (cleanupPath) {
-            try {
-                fs.unlinkSync(cleanupPath);
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
-    }
-}