@qvac/sdk 0.18.2 → 0.19.0

package/dist/schemas/model-types.js

@@ -1,223 +0,0 @@
-import { z } from 'zod';
-// === INTERNAL: Canonical types (used in SDK code) ===
-/**
- * Canonical model type values for internal SDK use.
- * Format: `engine-usecase` (e.g., "llamacpp-completion")
- * Use dot-accessor syntax: `ModelType.llamacppCompletion`
- */
-export const ModelType = {
-    llamacppCompletion: 'llamacpp-completion',
-    whispercppTranscription: 'whispercpp-transcription',
-    bciWhispercppTranscription: 'bci-whispercpp-transcription',
-    llamacppEmbedding: 'llamacpp-embedding',
-    nmtcppTranslation: 'nmtcpp-translation',
-    onnxTts: 'onnx-tts',
-    ttsGgml: 'tts-ggml',
-    parakeetTranscription: 'parakeet-transcription',
-    ggmlOcr: 'ggml-ocr',
-    sdcppGeneration: 'sdcpp-generation',
-    audiogenGgml: 'audiogen-ggml',
-    ggmlVla: 'ggml-vla',
-    ggmlClassification: 'ggml-classification'
-};
-// === INTERNAL: Alias keys (backward compat names) ===
-const AliasKeys = {
-    llm: 'llm',
-    whisper: 'whisper',
-    bci: 'bci',
-    embeddings: 'embeddings',
-    nmt: 'nmt',
-    parakeet: 'parakeet',
-    tts: 'tts',
-    ocr: 'ocr',
-    diffusion: 'diffusion',
-    audiogen: 'audiogen',
-    vla: 'vla',
-    classification: 'classification'
-};
-// === INTERNAL: Aliases (backward compat mapping) ===
-/**
- * Alias mappings for backward compatibility.
- * Maps old names to canonical values.
- */
-export const ModelTypeAliases = {
-    [AliasKeys.llm]: ModelType.llamacppCompletion,
-    [AliasKeys.whisper]: ModelType.whispercppTranscription,
-    [AliasKeys.bci]: ModelType.bciWhispercppTranscription,
-    [AliasKeys.embeddings]: ModelType.llamacppEmbedding,
-    [AliasKeys.nmt]: ModelType.nmtcppTranslation,
-    [AliasKeys.parakeet]: ModelType.parakeetTranscription,
-    [AliasKeys.tts]: ModelType.ttsGgml,
-    [AliasKeys.ocr]: ModelType.ggmlOcr,
-    [AliasKeys.diffusion]: ModelType.sdcppGeneration,
-    [AliasKeys.audiogen]: ModelType.audiogenGgml,
-    [AliasKeys.vla]: ModelType.ggmlVla,
-    [AliasKeys.classification]: ModelType.ggmlClassification
-};
-// Set of canonical values for quick lookup
-const canonicalValuesSet = new Set(Object.values(ModelType));
-// === PUBLIC: Combined (exported via index.ts as MODEL_TYPES) ===
-/**
- * All valid model types: canonical names + aliases.
- *
- * Canonical names follow `engine-usecase` format (e.g., "llamacpp-completion").
- * Aliases resolve to canonical names for backward compatibility.
- *
- * @example
- * ```typescript
- * // Preferred: canonical name
- * loadModel({ modelSrc: "...", modelType: MODEL_TYPES.nmtcppTranslation });
- *
- * // Deprecated: alias (still resolves to "nmtcpp-translation")
- * loadModel({ modelSrc: "...", modelType: MODEL_TYPES.nmt });
- * ```
- */
-export const PUBLIC_MODEL_TYPES = {
-    ...ModelType,
-    ...ModelTypeAliases
-};
-// === ZOD SCHEMAS ===
-// Derive input values from objects - no string repetition
-const inputValues = [
-    ...Object.values(ModelType),
-    ...Object.keys(ModelTypeAliases)
-];
-/** Schema accepting both canonical and alias model type inputs */
-export const modelTypeInputSchema = z.enum(inputValues);
-/** Schema that transforms input to canonical model type */
-export const modelTypeSchema = modelTypeInputSchema.transform((val) => {
-    // If already canonical, return as-is
-    if (canonicalValuesSet.has(val)) {
-        return val;
-    }
-    // Otherwise, look up in aliases
-    return ModelTypeAliases[val];
-});
-/**
- * Normalize model type input to canonical form.
- * Custom plugin types (not in built-ins) are returned as-is.
- */
-export function normalizeModelType(input) {
-    // If already canonical, return as-is
-    if (canonicalValuesSet.has(input)) {
-        return input;
-    }
-    // If it's an alias, normalize to canonical
-    if (input in ModelTypeAliases) {
-        return ModelTypeAliases[input];
-    }
-    // Custom plugin type - return as-is
-    return input;
-}
-/**
- * Type guard to check if a string is a canonical (built-in) model type.
- * Returns false for custom plugin types.
- */
-export function isCanonicalModelType(input) {
-    return canonicalValuesSet.has(input);
-}
-/**
- * Check if input is a built-in alias (not canonical or custom).
- * Returns false for custom plugin types.
- */
-export function isModelTypeAlias(input) {
-    return input in ModelTypeAliases;
-}
-// === PER-MODEL-TYPE SCHEMAS (for discriminated unions) ===
-// Extracted from root enum - no value duplication
-/**
- * LLM/Completion model type schema.
- * - Alias: `"llm"` → resolves to `"llamacpp-completion"`
- * - Canonical: `"llamacpp-completion"`
- */
-export const llmModelTypeSchema = modelTypeInputSchema
-    .extract([AliasKeys.llm, ModelType.llamacppCompletion])
-    .describe('LLM model type: "llm" (alias) or "llamacpp-completion" (canonical)');
-/**
- * Whisper/Transcription model type schema.
- * - Alias: `"whisper"` → resolves to `"whispercpp-transcription"`
- * - Canonical: `"whispercpp-transcription"`
- */
-export const whisperModelTypeSchema = modelTypeInputSchema
-    .extract([AliasKeys.whisper, ModelType.whispercppTranscription])
-    .describe('Whisper model type: "whisper" (alias) or "whispercpp-transcription" (canonical)');
-/**
- * BCI/Transcription model type schema.
- * - Alias: `"bci"` → resolves to `"bci-whispercpp-transcription"`
- * - Canonical: `"bci-whispercpp-transcription"`
- */
-export const bciModelTypeSchema = modelTypeInputSchema
-    .extract([AliasKeys.bci, ModelType.bciWhispercppTranscription])
-    .describe('BCI model type: "bci" (alias) or "bci-whispercpp-transcription" (canonical)');
-/**
- * Parakeet/Transcription model type schema.
- * - Alias: `"parakeet"` → resolves to `"parakeet-transcription"`
- * - Canonical: `"parakeet-transcription"`
- */
-export const parakeetModelTypeSchema = modelTypeInputSchema
-    .extract([AliasKeys.parakeet, ModelType.parakeetTranscription])
-    .describe('Parakeet model type: "parakeet" (alias) or "parakeet-transcription" (canonical)');
-/**
- * Embeddings model type schema.
- * - Alias: `"embeddings"` → resolves to `"llamacpp-embedding"`
- * - Canonical: `"llamacpp-embedding"`
- */
-export const embeddingsModelTypeSchema = modelTypeInputSchema
-    .extract([AliasKeys.embeddings, ModelType.llamacppEmbedding])
-    .describe('Embeddings model type: "embeddings" (alias) or "llamacpp-embedding" (canonical)');
-/**
- * NMT/Translation model type schema.
- * - Alias: `"nmt"` → resolves to `"nmtcpp-translation"`
- * - Canonical: `"nmtcpp-translation"`
- */
-export const nmtModelTypeSchema = modelTypeInputSchema
-    .extract([AliasKeys.nmt, ModelType.nmtcppTranslation])
-    .describe('NMT model type: "nmt" (alias) or "nmtcpp-translation" (canonical)');
-/**
- * TTS model type schema.
- * - Alias: `"tts"` → resolves to `"tts-ggml"`
- * - Canonical: `"tts-ggml"`
- */
-export const ttsModelTypeSchema = modelTypeInputSchema
-    .extract([AliasKeys.tts, ModelType.ttsGgml])
-    .describe('TTS model type: "tts" (alias) or "tts-ggml" (canonical)');
-/**
- * OCR model type schema.
- * - Alias: `"ocr"` → resolves to `"ggml-ocr"`
- * - Canonical: `"ggml-ocr"`
- */
-export const ocrModelTypeSchema = modelTypeInputSchema
-    .extract([AliasKeys.ocr, ModelType.ggmlOcr])
-    .describe('OCR model type: "ocr" (alias) or "ggml-ocr" (canonical)');
-/**
- * Diffusion/Image Generation model type schema.
- * - Alias: `"diffusion"` → resolves to `"sdcpp-generation"`
- * - Canonical: `"sdcpp-generation"`
- */
-export const diffusionModelTypeSchema = modelTypeInputSchema
-    .extract([AliasKeys.diffusion, ModelType.sdcppGeneration])
-    .describe('Diffusion model type: "diffusion" (alias) or "sdcpp-generation" (canonical)');
-/**
- * AudioGen model type schema.
- * - Alias: `"audiogen"` → resolves to `"audiogen-ggml"`
- * - Canonical: `"audiogen-ggml"`
- */
-export const audioGenModelTypeSchema = modelTypeInputSchema
-    .extract([AliasKeys.audiogen, ModelType.audiogenGgml])
-    .describe('AudioGen model type: "audiogen" (alias) or "audiogen-ggml" (canonical)');
-/**
- * VLA (vision-language-action) model type schema.
- * - Alias: `"vla"` → resolves to `"ggml-vla"`
- * - Canonical: `"ggml-vla"`
- */
-export const vlaModelTypeSchema = modelTypeInputSchema
-    .extract([AliasKeys.vla, ModelType.ggmlVla])
-    .describe('VLA model type: "vla" (alias) or "ggml-vla" (canonical)');
-/**
- * Image Classification model type schema.
- * - Alias: `"classification"` → resolves to `"ggml-classification"`
- * - Canonical: `"ggml-classification"`
- */
-export const classificationModelTypeSchema = modelTypeInputSchema
-    .extract([AliasKeys.classification, ModelType.ggmlClassification])
-    .describe('Classification model type: "classification" (alias) or "ggml-classification" (canonical)');

package/dist/schemas/ocr.d.ts

@@ -1,138 +0,0 @@
-import { z } from 'zod';
-export declare const ocrConfigSchema: z.ZodObject<{
-    langList: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    pipelineType: z.ZodOptional<z.ZodEnum<{
-        easyocr: "easyocr";
-        doctr: "doctr";
-    }>>;
-    magRatio: z.ZodOptional<z.ZodNumber>;
-    canvasSize: z.ZodOptional<z.ZodNumber>;
-    defaultRotationAngles: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-    contrastRetry: z.ZodOptional<z.ZodBoolean>;
-    lowConfidenceThreshold: z.ZodOptional<z.ZodNumber>;
-    recognizerBatchSize: z.ZodOptional<z.ZodNumber>;
-    nThreads: z.ZodOptional<z.ZodNumber>;
-    backendDevice: z.ZodOptional<z.ZodEnum<{
-        cpu: "cpu";
-        vulkan: "vulkan";
-        metal: "metal";
-        opencl: "opencl";
-    }>>;
-    gpuDevice: z.ZodOptional<z.ZodNumber>;
-    detectorModelSrc: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        src: z.ZodString;
-        name: z.ZodOptional<z.ZodString>;
-        modelId: z.ZodOptional<z.ZodString>;
-        registryPath: z.ZodOptional<z.ZodString>;
-        registrySource: z.ZodOptional<z.ZodString>;
-        blobCoreKey: z.ZodOptional<z.ZodString>;
-        blobIndex: z.ZodOptional<z.ZodNumber>;
-        engine: z.ZodOptional<z.ZodString>;
-        expectedSize: z.ZodOptional<z.ZodNumber>;
-        sha256Checksum: z.ZodOptional<z.ZodString>;
-        addon: z.ZodOptional<z.ZodUnion<readonly [z.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";
-        }>, z.ZodLiteral<"vad">]>>;
-    }, z.core.$strip>]>>;
-}, z.core.$strip>;
-export declare const imageInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"base64">;
-    value: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"filePath">;
-    value: z.ZodString;
-}, z.core.$strip>], "type">;
-export declare const ocrOptionsSchema: z.ZodObject<{
-    paragraph: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const ocrParamsSchema: z.ZodObject<{
-    modelId: z.ZodString;
-    image: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        type: z.ZodLiteral<"base64">;
-        value: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"filePath">;
-        value: z.ZodString;
-    }, z.core.$strip>], "type">;
-    options: z.ZodOptional<z.ZodObject<{
-        paragraph: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const ocrStreamRequestSchema: z.ZodObject<{
-    modelId: z.ZodString;
-    image: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        type: z.ZodLiteral<"base64">;
-        value: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"filePath">;
-        value: z.ZodString;
-    }, z.core.$strip>], "type">;
-    options: z.ZodOptional<z.ZodObject<{
-        paragraph: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    type: z.ZodLiteral<"ocrStream">;
-}, z.core.$strip>;
-export declare const ocrTextBlockSchema: z.ZodObject<{
-    text: z.ZodString;
-    bbox: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
-    confidence: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export declare const ocrStatsSchema: z.ZodObject<{
-    detectionTime: z.ZodOptional<z.ZodNumber>;
-    recognitionTime: z.ZodOptional<z.ZodNumber>;
-    totalTime: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export declare const ocrStreamResponseSchema: z.ZodObject<{
-    type: z.ZodLiteral<"ocrStream">;
-    blocks: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        text: z.ZodString;
-        bbox: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
-        confidence: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>>;
-    done: z.ZodOptional<z.ZodBoolean>;
-    error: z.ZodOptional<z.ZodString>;
-    stats: z.ZodOptional<z.ZodObject<{
-        detectionTime: z.ZodOptional<z.ZodNumber>;
-        recognitionTime: z.ZodOptional<z.ZodNumber>;
-        totalTime: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type OCRConfig = z.infer<typeof ocrConfigSchema>;
-export type ImageInput = z.infer<typeof imageInputSchema>;
-export type OCROptions = z.infer<typeof ocrOptionsSchema>;
-export type OCRParams = z.infer<typeof ocrParamsSchema>;
-export type OCRClientParams = {
-    modelId: string;
-    image: string | Buffer;
-    options?: OCROptions;
-    stream?: boolean;
-};
-export type OCRStreamRequest = z.infer<typeof ocrStreamRequestSchema>;
-export type OCRStreamResponse = z.infer<typeof ocrStreamResponseSchema>;
-export type OCRTextBlock = z.infer<typeof ocrTextBlockSchema>;
-export type OCRStats = z.infer<typeof ocrStatsSchema>;
-//# sourceMappingURL=ocr.d.ts.map

package/dist/schemas/ocr.js

@@ -1,59 +0,0 @@
-import { z } from 'zod';
-import { modelSrcInputSchema } from './model-src-utils.js';
-// Model config — maps to @qvac/ocr-ggml `OcrGgmlParams`. Legacy ONNX-only knobs
-// (useGPU, timeout, pipelineMode, decodingMethod, straightenPages) are dropped;
-// zod's default (non-strict) object strips them silently if still passed.
-export const ocrConfigSchema = z.object({
-    langList: z.array(z.string()).optional(),
-    pipelineType: z.enum(['easyocr', 'doctr']).optional(),
-    magRatio: z.number().optional(),
-    canvasSize: z.number().optional(),
-    defaultRotationAngles: z.array(z.number()).optional(),
-    contrastRetry: z.boolean().optional(),
-    lowConfidenceThreshold: z.number().optional(),
-    recognizerBatchSize: z.number().optional(),
-    nThreads: z.number().optional(),
-    backendDevice: z.enum(['cpu', 'vulkan', 'metal', 'opencl']).optional(),
-    gpuDevice: z.number().optional(),
-    detectorModelSrc: modelSrcInputSchema.optional()
-});
-// Image input types
-export const imageInputSchema = z.discriminatedUnion('type', [
-    z.object({
-        type: z.literal('base64'),
-        value: z.string()
-    }),
-    z.object({
-        type: z.literal('filePath'),
-        value: z.string()
-    })
-]);
-// OCR options
-export const ocrOptionsSchema = z.object({
-    paragraph: z.boolean().optional()
-});
-export const ocrParamsSchema = z.object({
-    modelId: z.string(),
-    image: imageInputSchema,
-    options: ocrOptionsSchema.optional()
-});
-export const ocrStreamRequestSchema = ocrParamsSchema.extend({
-    type: z.literal('ocrStream')
-});
-export const ocrTextBlockSchema = z.object({
-    text: z.string(),
-    bbox: z.tuple([z.number(), z.number(), z.number(), z.number()]).optional(),
-    confidence: z.number().optional()
-});
-export const ocrStatsSchema = z.object({
-    detectionTime: z.number().optional(),
-    recognitionTime: z.number().optional(),
-    totalTime: z.number().optional()
-});
-export const ocrStreamResponseSchema = z.object({
-    type: z.literal('ocrStream'),
-    blocks: z.array(ocrTextBlockSchema).optional(),
-    done: z.boolean().optional(),
-    error: z.string().optional(),
-    stats: ocrStatsSchema.optional()
-});

package/dist/schemas/path-validation.d.ts

@@ -1,10 +0,0 @@
-import { z } from 'zod';
-/**
- * Zod refinement for path components that get joined to a base directory.
- * Rejects strings containing traversal sequences (.., null bytes).
- *
- * DO NOT apply to fields that accept absolute user paths (e.g. audio, image,
- * model, or attachment paths).
- */
-export declare const safePathComponent: z.ZodString;
-//# sourceMappingURL=path-validation.d.ts.map

package/dist/schemas/path-validation.js

@@ -1,22 +0,0 @@
-import { z } from 'zod';
-/**
- * Zod refinement for path components that get joined to a base directory.
- * Rejects strings containing traversal sequences (.., null bytes).
- *
- * DO NOT apply to fields that accept absolute user paths (e.g. audio, image,
- * model, or attachment paths).
- */
-export const safePathComponent = z.string().refine((s) => {
-    // Reject literal traversal
-    if (s.includes('..'))
-        return false;
-    // Reject null bytes (literal and URL-encoded)
-    if (s.includes('\0') || s.toLowerCase().includes('%00'))
-        return false;
-    // Reject URL-encoded traversal (%2e = ".", %2f = "/", %5c = "\")
-    if (/%2e/i.test(s))
-        return false;
-    return true;
-}, {
-    message: "Path component must not contain traversal sequences ('..', '%2e'), null bytes, or '%00'"
-});