@qvac/sdk 0.4.1 → 0.6.0

package/dist/schemas/load-model.js

@@ -1,15 +1,18 @@
 import { z } from "zod";
-import { llmConfigSchema, embedConfigSchema } from "./llamacpp-config.js";
+import { llmConfigBaseSchema, embedConfigBaseSchema, } from "./llamacpp-config.js";
 import { whisperConfigSchema } from "./whispercpp-config.js";
 import { delegateSchema } from "./delegate.js";
 import { nmtConfigSchema } from "./translation-config.js";
 import { ttsConfigSchema } from "./text-to-speech.js";
+import { ocrConfigSchema } from "./ocr.js";
 import { modelSrcInputSchema, modelInputToSrcSchema, modelInputToNameSchema, } from "./model-src-utils.js";
+import { llmModelTypeSchema, whisperModelTypeSchema, embeddingsModelTypeSchema, nmtModelTypeSchema, ttsModelTypeSchema, ocrModelTypeSchema, ModelType, } from "./model-types.js";
+import { reloadConfigRequestSchema } from "./reload-config.js";
 const loadModelOptionsBaseSchema = z.union([
     z.object({
         modelSrc: modelSrcInputSchema,
-        modelType: z.literal("llm"),
-        modelConfig: llmConfigSchema.partial().strict().optional(),
+        modelType: llmModelTypeSchema,
+        modelConfig: llmConfigBaseSchema.strict().optional(),
         seed: z.boolean().optional(),
         projectionModelSrc: modelSrcInputSchema.optional(),
         delegate: delegateSchema,
@@ -17,7 +20,7 @@ const loadModelOptionsBaseSchema = z.union([
     }),
     z.object({
         modelSrc: modelSrcInputSchema,
-        modelType: z.literal("whisper"),
+        modelType: whisperModelTypeSchema,
         modelConfig: whisperConfigSchema.partial().strict().optional(),
         seed: z.boolean().optional(),
         vadModelSrc: modelSrcInputSchema.optional(),
@@ -25,27 +28,37 @@ const loadModelOptionsBaseSchema = z.union([
     }),
     z.object({
         modelSrc: modelSrcInputSchema,
-        modelType: z.literal("embeddings"),
-        modelConfig: embedConfigSchema.partial().strict().optional(),
+        modelType: embeddingsModelTypeSchema,
+        modelConfig: embedConfigBaseSchema.strict().optional(),
         seed: z.boolean().optional(),
         delegate: delegateSchema,
     }),
     z.object({
         modelSrc: modelSrcInputSchema,
-        modelType: z.literal("nmt"),
+        modelType: nmtModelTypeSchema,
         modelConfig: nmtConfigSchema,
+        srcVocabSrc: modelSrcInputSchema.optional(),
+        dstVocabSrc: modelSrcInputSchema.optional(),
         seed: z.boolean().optional(),
         delegate: delegateSchema,
     }),
     z.object({
         modelSrc: modelSrcInputSchema,
-        modelType: z.literal("tts"),
+        modelType: ttsModelTypeSchema,
         modelConfig: ttsConfigSchema,
         configSrc: modelSrcInputSchema,
         eSpeakDataPath: z.string(),
         seed: z.boolean().optional(),
         delegate: delegateSchema,
     }),
+    z.object({
+        modelSrc: modelSrcInputSchema,
+        modelType: ocrModelTypeSchema,
+        modelConfig: ocrConfigSchema.partial().strict().optional(),
+        detectorModelSrc: modelSrcInputSchema.optional(),
+        seed: z.boolean().optional(),
+        delegate: delegateSchema,
+    }),
 ]);
 export const loadModelOptionsSchema = loadModelOptionsBaseSchema.transform((data) => ({
     ...data,
@@ -55,8 +68,8 @@ export const loadModelOptionsToRequestSchema = z.union([
     z
         .object({
         modelSrc: modelSrcInputSchema,
-        modelType: z.literal("llm"),
-        modelConfig: llmConfigSchema.partial().strict().optional(),
+        modelType: llmModelTypeSchema,
+        modelConfig: llmConfigBaseSchema.strict().optional(),
         seed: z.boolean().optional(),
         projectionModelSrc: modelSrcInputSchema.optional(),
         delegate: delegateSchema,
@@ -66,7 +79,7 @@ export const loadModelOptionsToRequestSchema = z.union([
     })
         .transform((data) => ({
         type: "loadModel",
-        modelType: "llm",
+        modelType: ModelType.llamacppCompletion,
         modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
         modelName: modelInputToNameSchema.parse(data.modelSrc),
         modelConfig: (data.modelConfig ?? {}),
@@ -80,7 +93,7 @@ export const loadModelOptionsToRequestSchema = z.union([
     z
         .object({
         modelSrc: modelSrcInputSchema,
-        modelType: z.literal("whisper"),
+        modelType: whisperModelTypeSchema,
         modelConfig: whisperConfigSchema.partial().strict().optional(),
         seed: z.boolean().optional(),
         vadModelSrc: modelSrcInputSchema.optional(),
@@ -90,7 +103,7 @@ export const loadModelOptionsToRequestSchema = z.union([
     })
         .transform((data) => ({
         type: "loadModel",
-        modelType: "whisper",
+        modelType: ModelType.whispercppTranscription,
         modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
         modelName: modelInputToNameSchema.parse(data.modelSrc),
         modelConfig: (data.modelConfig ?? {}),
@@ -104,8 +117,8 @@ export const loadModelOptionsToRequestSchema = z.union([
     z
         .object({
         modelSrc: modelSrcInputSchema,
-        modelType: z.literal("embeddings"),
-        modelConfig: embedConfigSchema.partial().strict().optional(),
+        modelType: embeddingsModelTypeSchema,
+        modelConfig: embedConfigBaseSchema.strict().optional(),
         seed: z.boolean().optional(),
         delegate: delegateSchema,
         onProgress: z.unknown().optional(),
@@ -113,7 +126,7 @@ export const loadModelOptionsToRequestSchema = z.union([
     })
         .transform((data) => ({
         type: "loadModel",
-        modelType: "embeddings",
+        modelType: ModelType.llamacppEmbedding,
         modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
         modelName: modelInputToNameSchema.parse(data.modelSrc),
         modelConfig: (data.modelConfig ?? {}),
@@ -124,8 +137,10 @@ export const loadModelOptionsToRequestSchema = z.union([
     z
         .object({
         modelSrc: modelSrcInputSchema,
-        modelType: z.literal("nmt"),
+        modelType: nmtModelTypeSchema,
         modelConfig: nmtConfigSchema,
+        srcVocabSrc: modelSrcInputSchema.optional(),
+        dstVocabSrc: modelSrcInputSchema.optional(),
         seed: z.boolean().optional(),
         delegate: delegateSchema,
         onProgress: z.unknown().optional(),
@@ -133,10 +148,16 @@ export const loadModelOptionsToRequestSchema = z.union([
     })
         .transform((data) => ({
         type: "loadModel",
-        modelType: "nmt",
+        modelType: ModelType.nmtcppTranslation,
         modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
         modelName: modelInputToNameSchema.parse(data.modelSrc),
         modelConfig: data.modelConfig,
+        srcVocabSrc: data.srcVocabSrc
+            ? modelInputToSrcSchema.parse(data.srcVocabSrc)
+            : undefined,
+        dstVocabSrc: data.dstVocabSrc
+            ? modelInputToSrcSchema.parse(data.dstVocabSrc)
+            : undefined,
         seed: data.seed ?? false,
         withProgress: data.withProgress ?? !!data.onProgress,
         delegate: data.delegate,
@@ -144,7 +165,7 @@ export const loadModelOptionsToRequestSchema = z.union([
     z
         .object({
         modelSrc: modelSrcInputSchema,
-        modelType: z.literal("tts"),
+        modelType: ttsModelTypeSchema,
         modelConfig: ttsConfigSchema,
         configSrc: modelSrcInputSchema,
         eSpeakDataPath: z.string(),
@@ -155,7 +176,7 @@ export const loadModelOptionsToRequestSchema = z.union([
     })
         .transform((data) => ({
         type: "loadModel",
-        modelType: "tts",
+        modelType: ModelType.onnxTts,
         modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
         modelName: modelInputToNameSchema.parse(data.modelSrc),
         modelConfig: data.modelConfig,
@@ -165,6 +186,30 @@ export const loadModelOptionsToRequestSchema = z.union([
         configSrc: modelInputToSrcSchema.parse(data.configSrc),
         eSpeakDataPath: data.eSpeakDataPath,
     })),
+    z
+        .object({
+        modelSrc: modelSrcInputSchema,
+        modelType: ocrModelTypeSchema,
+        modelConfig: ocrConfigSchema.partial().strict().optional(),
+        detectorModelSrc: modelSrcInputSchema.optional(),
+        seed: z.boolean().optional(),
+        delegate: delegateSchema,
+        onProgress: z.unknown().optional(),
+        withProgress: z.boolean().optional(),
+    })
+        .transform((data) => ({
+        type: "loadModel",
+        modelType: ModelType.onnxOcr,
+        modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
+        modelName: modelInputToNameSchema.parse(data.modelSrc),
+        modelConfig: (data.modelConfig ?? {}),
+        seed: data.seed ?? false,
+        withProgress: data.withProgress ?? !!data.onProgress,
+        delegate: data.delegate,
+        detectorModelSrc: data.detectorModelSrc
+            ? modelInputToSrcSchema.parse(data.detectorModelSrc)
+            : undefined,
+    })),
 ]);
 const commonModelConfigSchema = z.object({
     type: z.literal("loadModel"),
@@ -173,46 +218,61 @@ const commonModelConfigSchema = z.object({
     projectionModelSrc: z.string().optional(),
     vadModelSrc: z.string().optional(),
     configSrc: z.string().optional(),
+    detectorModelSrc: z.string().optional(),
     withProgress: z.boolean().optional(),
     seed: z.boolean().optional(),
     delegate: delegateSchema,
 });
-// Request schemas for each model type
+// Request schemas for each model type (use canonical types since transforms normalize)
+// Use base schemas (no defaults) for client-side validation.
+// Server applies device defaults, then full schema defaults.
 export const loadLlmModelRequestSchema = commonModelConfigSchema.extend({
-    modelType: z.literal("llm"),
-    modelConfig: llmConfigSchema,
+    modelType: z.literal(ModelType.llamacppCompletion),
+    modelConfig: llmConfigBaseSchema,
 });
 export const loadWhisperModelRequestSchema = commonModelConfigSchema.extend({
-    modelType: z.literal("whisper"),
-    modelConfig: whisperConfigSchema,
+    modelType: z.literal(ModelType.whispercppTranscription),
+    modelConfig: whisperConfigSchema, // whisper has no defaults
 });
 export const loadEmbeddingsModelRequestSchema = commonModelConfigSchema.extend({
-    modelType: z.literal("embeddings"),
-    modelConfig: embedConfigSchema,
+    modelType: z.literal(ModelType.llamacppEmbedding),
+    modelConfig: embedConfigBaseSchema,
 });
 export const loadNmtModelRequestSchema = commonModelConfigSchema.extend({
-    modelType: z.literal("nmt"),
-    modelConfig: nmtConfigSchema,
+    modelType: z.literal(ModelType.nmtcppTranslation),
+    modelConfig: nmtConfigSchema, // nmt has no defaults
+    srcVocabSrc: z.string().optional(),
+    dstVocabSrc: z.string().optional(),
 });
 export const loadTtsModelRequestSchema = commonModelConfigSchema.extend({
-    modelType: z.literal("tts"),
-    modelConfig: ttsConfigSchema,
+    modelType: z.literal(ModelType.onnxTts),
+    modelConfig: ttsConfigSchema, // tts has no defaults
     configSrc: z.string(),
     eSpeakDataPath: z.string(),
 });
-// Union of all load model request types
-export const loadModelRequestSchema = z
-    .discriminatedUnion("modelType", [
+export const loadOcrModelRequestSchema = commonModelConfigSchema.extend({
+    modelType: z.literal(ModelType.onnxOcr),
+    modelConfig: ocrConfigSchema, // ocr has no defaults
+});
+// Union of all load model request types (using z.union since each modelType accepts multiple values)
+export const loadModelSrcRequestSchema = z
+    .union([
     loadLlmModelRequestSchema,
     loadWhisperModelRequestSchema,
     loadEmbeddingsModelRequestSchema,
     loadNmtModelRequestSchema,
     loadTtsModelRequestSchema,
+    loadOcrModelRequestSchema,
 ])
     .transform((data) => ({
     ...data,
     seed: data.seed ?? false,
 }));
+// Combined request schema: load new model OR reload config
+export const loadModelRequestSchema = z.union([
+    loadModelSrcRequestSchema,
+    reloadConfigRequestSchema,
+]);
 export const loadModelResponseSchema = z.object({
     type: z.literal("loadModel"),
     success: z.boolean(),
@@ -251,5 +311,6 @@ export const loadModelServerParamsSchema = z.object({
     vadModelPath: z.string().optional(),
     ttsConfigModelPath: z.string().optional(),
     eSpeakDataPath: z.string().optional(),
+    detectorModelPath: z.string().optional(),
     modelName: z.string().optional(),
 });

package/dist/schemas/logging-stream.d.ts

@@ -1,20 +1,27 @@
 import { z } from "zod";
+export declare const logLevelSchema: z.ZodEnum<{
+    error: "error";
+    off: "off";
+    warn: "warn";
+    info: "info";
+    debug: "debug";
+}>;
 declare const loggingParamsSchema: z.ZodObject<{
-    modelId: z.ZodString;
+    id: z.ZodString;
 }, z.core.$strip>;
 export declare const loggingStreamRequestSchema: z.ZodObject<{
-    modelId: z.ZodString;
+    id: z.ZodString;
     type: z.ZodLiteral<"loggingStream">;
 }, z.core.$strip>;
 export declare const loggingStreamResponseSchema: z.ZodObject<{
     type: z.ZodLiteral<"loggingStream">;
-    modelId: z.ZodString;
+    id: z.ZodString;
     level: z.ZodEnum<{
         error: "error";
+        off: "off";
         warn: "warn";
         info: "info";
         debug: "debug";
-        off: "off";
     }>;
     namespace: z.ZodString;
     message: z.ZodString;

package/dist/schemas/logging-stream.js

@@ -1,15 +1,16 @@
 import { z } from "zod";
 const logLevelValues = ["error", "warn", "info", "debug"];
+export const logLevelSchema = z.enum(logLevelValues);
 const loggingParamsSchema = z.object({
-    modelId: z.string(),
+    id: z.string(),
 });
 export const loggingStreamRequestSchema = loggingParamsSchema.extend({
     type: z.literal("loggingStream"),
 });
 export const loggingStreamResponseSchema = z.object({
     type: z.literal("loggingStream"),
-    modelId: z.string(),
-    level: z.enum(logLevelValues),
+    id: z.string(),
+    level: logLevelSchema,
     namespace: z.string(),
     message: z.string(),
     timestamp: z.number(),

package/dist/schemas/mcp-adapter.d.ts

@@ -0,0 +1,47 @@
+import type { JsonSchema } from "./json-schema";
+export type McpTool = {
+    name: string;
+    description?: string | undefined;
+    inputSchema: JsonSchema | Record<string, unknown>;
+};
+export type McpResource = {
+    uri: string;
+    name: string;
+    description?: string | undefined;
+    mimeType?: string | undefined;
+};
+export type McpToolCallResult = {
+    content?: Array<{
+        type: string;
+        text?: string | undefined;
+        data?: string | undefined;
+        mimeType?: string | undefined;
+    }>;
+    toolResult?: unknown;
+    isError?: boolean | undefined;
+};
+export type McpClient = {
+    listTools: () => Promise<{
+        tools: McpTool[];
+        [key: string]: unknown;
+    }>;
+    callTool: (params: {
+        name: string;
+        arguments: Record<string, unknown>;
+    }) => Promise<McpToolCallResult | Record<string, unknown>>;
+    listResources?: () => Promise<{
+        resources: McpResource[];
+        [key: string]: unknown;
+    }>;
+    readResource?: (params: {
+        uri: string;
+    }) => Promise<{
+        contents: unknown[];
+        [key: string]: unknown;
+    }>;
+};
+export type McpClientInput = {
+    client: McpClient;
+    includeResources?: boolean;
+};
+//# sourceMappingURL=mcp-adapter.d.ts.map

package/dist/schemas/mcp-adapter.js

@@ -0,0 +1 @@
+export {};

package/dist/schemas/model-src-utils.d.ts

@@ -7,14 +7,20 @@ export declare const modelDescriptorSchema: z.ZodObject<{
     hyperbeeKey: z.ZodOptional<z.ZodString>;
     expectedSize: z.ZodOptional<z.ZodNumber>;
     sha256Checksum: z.ZodOptional<z.ZodString>;
-    addon: z.ZodOptional<z.ZodEnum<{
+    addon: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        "llamacpp-completion": "llamacpp-completion";
+        "whispercpp-transcription": "whispercpp-transcription";
+        "llamacpp-embedding": "llamacpp-embedding";
+        "nmtcpp-translation": "nmtcpp-translation";
+        "onnx-tts": "onnx-tts";
+        "onnx-ocr": "onnx-ocr";
         llm: "llm";
         whisper: "whisper";
         embeddings: "embeddings";
         nmt: "nmt";
-        vad: "vad";
         tts: "tts";
-    }>>;
+        ocr: "ocr";
+    }>, z.ZodLiteral<"vad">]>>;
 }, z.core.$strip>;
 export declare const modelSrcInputSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
     src: z.ZodString;
@@ -24,14 +30,20 @@ export declare const modelSrcInputSchema: z.ZodUnion<readonly [z.ZodString, z.Zo
     hyperbeeKey: z.ZodOptional<z.ZodString>;
     expectedSize: z.ZodOptional<z.ZodNumber>;
     sha256Checksum: z.ZodOptional<z.ZodString>;
-    addon: z.ZodOptional<z.ZodEnum<{
+    addon: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        "llamacpp-completion": "llamacpp-completion";
+        "whispercpp-transcription": "whispercpp-transcription";
+        "llamacpp-embedding": "llamacpp-embedding";
+        "nmtcpp-translation": "nmtcpp-translation";
+        "onnx-tts": "onnx-tts";
+        "onnx-ocr": "onnx-ocr";
         llm: "llm";
         whisper: "whisper";
         embeddings: "embeddings";
         nmt: "nmt";
-        vad: "vad";
         tts: "tts";
-    }>>;
+        ocr: "ocr";
+    }>, z.ZodLiteral<"vad">]>>;
 }, z.core.$strip>]>;
 export type ModelDescriptor = z.infer<typeof modelDescriptorSchema>;
 export type ModelSrcInput = z.infer<typeof modelSrcInputSchema>;
@@ -47,14 +59,20 @@ export declare const modelInputToSrcSchema: z.ZodPipe<z.ZodUnion<readonly [z.Zod
     hyperbeeKey: z.ZodOptional<z.ZodString>;
     expectedSize: z.ZodOptional<z.ZodNumber>;
     sha256Checksum: z.ZodOptional<z.ZodString>;
-    addon: z.ZodOptional<z.ZodEnum<{
+    addon: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        "llamacpp-completion": "llamacpp-completion";
+        "whispercpp-transcription": "whispercpp-transcription";
+        "llamacpp-embedding": "llamacpp-embedding";
+        "nmtcpp-translation": "nmtcpp-translation";
+        "onnx-tts": "onnx-tts";
+        "onnx-ocr": "onnx-ocr";
         llm: "llm";
         whisper: "whisper";
         embeddings: "embeddings";
         nmt: "nmt";
-        vad: "vad";
         tts: "tts";
-    }>>;
+        ocr: "ocr";
+    }>, z.ZodLiteral<"vad">]>>;
 }, z.core.$strip>]>, z.ZodTransform<string, string | {
     src: string;
     name?: string | undefined;
@@ -63,7 +81,7 @@ export declare const modelInputToSrcSchema: z.ZodPipe<z.ZodUnion<readonly [z.Zod
     hyperbeeKey?: string | undefined;
     expectedSize?: number | undefined;
     sha256Checksum?: string | undefined;
-    addon?: "llm" | "whisper" | "embeddings" | "nmt" | "vad" | "tts" | undefined;
+    addon?: "llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "onnx-ocr" | "llm" | "whisper" | "embeddings" | "nmt" | "tts" | "ocr" | "vad" | undefined;
 }>>;
 /**
  * Schema that transforms ModelSrc to its optional name
@@ -77,14 +95,20 @@ export declare const modelInputToNameSchema: z.ZodPipe<z.ZodUnion<readonly [z.Zo
     hyperbeeKey: z.ZodOptional<z.ZodString>;
     expectedSize: z.ZodOptional<z.ZodNumber>;
     sha256Checksum: z.ZodOptional<z.ZodString>;
-    addon: z.ZodOptional<z.ZodEnum<{
+    addon: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        "llamacpp-completion": "llamacpp-completion";
+        "whispercpp-transcription": "whispercpp-transcription";
+        "llamacpp-embedding": "llamacpp-embedding";
+        "nmtcpp-translation": "nmtcpp-translation";
+        "onnx-tts": "onnx-tts";
+        "onnx-ocr": "onnx-ocr";
         llm: "llm";
         whisper: "whisper";
         embeddings: "embeddings";
         nmt: "nmt";
-        vad: "vad";
         tts: "tts";
-    }>>;
+        ocr: "ocr";
+    }>, z.ZodLiteral<"vad">]>>;
 }, z.core.$strip>]>, z.ZodTransform<string | undefined, string | {
     src: string;
     name?: string | undefined;
@@ -93,6 +117,6 @@ export declare const modelInputToNameSchema: z.ZodPipe<z.ZodUnion<readonly [z.Zo
     hyperbeeKey?: string | undefined;
     expectedSize?: number | undefined;
     sha256Checksum?: string | undefined;
-    addon?: "llm" | "whisper" | "embeddings" | "nmt" | "vad" | "tts" | undefined;
+    addon?: "llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "onnx-ocr" | "llm" | "whisper" | "embeddings" | "nmt" | "tts" | "ocr" | "vad" | undefined;
 }>>;
 //# sourceMappingURL=model-src-utils.d.ts.map

package/dist/schemas/model-src-utils.js

@@ -1,4 +1,7 @@
 import { z } from "zod";
+import { modelTypeInputSchema } from "./model-types.js";
+// Addon field accepts model type inputs plus "vad"
+const addonSchema = z.union([modelTypeInputSchema, z.literal("vad")]);
 export const modelDescriptorSchema = z.object({
     src: z.string(),
     name: z.string().optional(),
@@ -7,9 +10,7 @@ export const modelDescriptorSchema = z.object({
     hyperbeeKey: z.string().optional(),
     expectedSize: z.number().optional(),
     sha256Checksum: z.string().optional(),
-    addon: z
-        .enum(["llm", "whisper", "embeddings", "nmt", "vad", "tts"])
-        .optional(),
+    addon: addonSchema.optional(),
 });
 export const modelSrcInputSchema = z.union([z.string(), modelDescriptorSchema]);
 /**

package/dist/schemas/model-types.d.ts

@@ -0,0 +1,154 @@
+import { z } from "zod";
+/**
+ * Canonical model type values for internal SDK use.
+ * Format: `engine-usecase` (e.g., "llamacpp-completion")
+ * Use dot-accessor syntax: `ModelType.llamacppCompletion`
+ */
+export declare const ModelType: {
+    readonly llamacppCompletion: "llamacpp-completion";
+    readonly whispercppTranscription: "whispercpp-transcription";
+    readonly llamacppEmbedding: "llamacpp-embedding";
+    readonly nmtcppTranslation: "nmtcpp-translation";
+    readonly onnxTts: "onnx-tts";
+    readonly onnxOcr: "onnx-ocr";
+};
+/**
+ * Alias mappings for backward compatibility.
+ * Maps old names to canonical values.
+ */
+export declare const ModelTypeAliases: {
+    readonly llm: "llamacpp-completion";
+    readonly whisper: "whispercpp-transcription";
+    readonly embeddings: "llamacpp-embedding";
+    readonly nmt: "nmtcpp-translation";
+    readonly tts: "onnx-tts";
+    readonly ocr: "onnx-ocr";
+};
+export type CanonicalModelType = (typeof ModelType)[keyof typeof ModelType];
+export type AliasKey = keyof typeof ModelTypeAliases;
+export type ModelTypeInput = CanonicalModelType | AliasKey;
+/**
+ * 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
+ * // Using alias (backward compatible)
+ * loadModel({ modelSrc: "...", modelType: MODEL_TYPES.nmt });
+ * // MODEL_TYPES.nmt resolves to "nmtcpp-translation"
+ *
+ * // Using canonical name directly
+ * loadModel({ modelSrc: "...", modelType: MODEL_TYPES.nmtcppTranslation });
+ * ```
+ */
+export declare const PUBLIC_MODEL_TYPES: {
+    readonly llm: "llamacpp-completion";
+    readonly whisper: "whispercpp-transcription";
+    readonly embeddings: "llamacpp-embedding";
+    readonly nmt: "nmtcpp-translation";
+    readonly tts: "onnx-tts";
+    readonly ocr: "onnx-ocr";
+    readonly llamacppCompletion: "llamacpp-completion";
+    readonly whispercppTranscription: "whispercpp-transcription";
+    readonly llamacppEmbedding: "llamacpp-embedding";
+    readonly nmtcppTranslation: "nmtcpp-translation";
+    readonly onnxTts: "onnx-tts";
+    readonly onnxOcr: "onnx-ocr";
+};
+/** Schema accepting both canonical and alias model type inputs */
+export declare const modelTypeInputSchema: z.ZodEnum<{
+    "llamacpp-completion": "llamacpp-completion";
+    "whispercpp-transcription": "whispercpp-transcription";
+    "llamacpp-embedding": "llamacpp-embedding";
+    "nmtcpp-translation": "nmtcpp-translation";
+    "onnx-tts": "onnx-tts";
+    "onnx-ocr": "onnx-ocr";
+    llm: "llm";
+    whisper: "whisper";
+    embeddings: "embeddings";
+    nmt: "nmt";
+    tts: "tts";
+    ocr: "ocr";
+}>;
+/** Schema that transforms input to canonical model type */
+export declare const modelTypeSchema: z.ZodPipe<z.ZodEnum<{
+    "llamacpp-completion": "llamacpp-completion";
+    "whispercpp-transcription": "whispercpp-transcription";
+    "llamacpp-embedding": "llamacpp-embedding";
+    "nmtcpp-translation": "nmtcpp-translation";
+    "onnx-tts": "onnx-tts";
+    "onnx-ocr": "onnx-ocr";
+    llm: "llm";
+    whisper: "whisper";
+    embeddings: "embeddings";
+    nmt: "nmt";
+    tts: "tts";
+    ocr: "ocr";
+}>, z.ZodTransform<"llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "onnx-ocr", "llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "onnx-ocr" | "llm" | "whisper" | "embeddings" | "nmt" | "tts" | "ocr">>;
+/** Normalize model type input to canonical form */
+export declare function normalizeModelType(input: ModelTypeInput): CanonicalModelType;
+/** Check if input is an alias (not canonical) */
+export declare function isModelTypeAlias(input: ModelTypeInput): boolean;
+/**
+ * LLM/Completion model type schema.
+ * - Alias: `"llm"` → resolves to `"llamacpp-completion"`
+ * - Canonical: `"llamacpp-completion"`
+ */
+export declare const llmModelTypeSchema: z.ZodEnum<{
+    "llamacpp-completion": "llamacpp-completion";
+    llm: "llm";
+}>;
+export type LlmModelTypeInput = z.infer<typeof llmModelTypeSchema>;
+/**
+ * Whisper/Transcription model type schema.
+ * - Alias: `"whisper"` → resolves to `"whispercpp-transcription"`
+ * - Canonical: `"whispercpp-transcription"`
+ */
+export declare const whisperModelTypeSchema: z.ZodEnum<{
+    "whispercpp-transcription": "whispercpp-transcription";
+    whisper: "whisper";
+}>;
+export type WhisperModelTypeInput = z.infer<typeof whisperModelTypeSchema>;
+/**
+ * Embeddings model type schema.
+ * - Alias: `"embeddings"` → resolves to `"llamacpp-embedding"`
+ * - Canonical: `"llamacpp-embedding"`
+ */
+export declare const embeddingsModelTypeSchema: z.ZodEnum<{
+    "llamacpp-embedding": "llamacpp-embedding";
+    embeddings: "embeddings";
+}>;
+export type EmbeddingsModelTypeInput = z.infer<typeof embeddingsModelTypeSchema>;
+/**
+ * NMT/Translation model type schema.
+ * - Alias: `"nmt"` → resolves to `"nmtcpp-translation"`
+ * - Canonical: `"nmtcpp-translation"`
+ */
+export declare const nmtModelTypeSchema: z.ZodEnum<{
+    "nmtcpp-translation": "nmtcpp-translation";
+    nmt: "nmt";
+}>;
+export type NmtModelTypeInput = z.infer<typeof nmtModelTypeSchema>;
+/**
+ * TTS model type schema.
+ * - Alias: `"tts"` → resolves to `"onnx-tts"`
+ * - Canonical: `"onnx-tts"`
+ */
+export declare const ttsModelTypeSchema: z.ZodEnum<{
+    "onnx-tts": "onnx-tts";
+    tts: "tts";
+}>;
+export type TtsModelTypeInput = z.infer<typeof ttsModelTypeSchema>;
+/**
+ * OCR model type schema.
+ * - Alias: `"ocr"` → resolves to `"onnx-ocr"`
+ * - Canonical: `"onnx-ocr"`
+ */
+export declare const ocrModelTypeSchema: z.ZodEnum<{
+    "onnx-ocr": "onnx-ocr";
+    ocr: "ocr";
+}>;
+export type OcrModelTypeInput = z.infer<typeof ocrModelTypeSchema>;
+//# sourceMappingURL=model-types.d.ts.map