@qvac/sdk 0.5.0 → 0.6.0

package/dist/schemas/sdk-config.js

@@ -1,5 +1,70 @@
 import { z } from "zod";
 import { logLevelSchema } from "./logging-stream.js";
+import { ModelType } from "./model-types.js";
+import { llmConfigBaseSchema, embedConfigBaseSchema } from "./llamacpp-config.js";
+import { whisperConfigSchema } from "./whispercpp-config.js";
+import { ocrConfigSchema } from "./ocr.js";
+import { runtimeContextSchema } from "./runtime-context.js";
+// Alias keys for user convenience (maps to canonical types)
+const AliasKeys = {
+    llm: "llm",
+    whisper: "whisper",
+    embeddings: "embeddings",
+    nmt: "nmt",
+    tts: "tts",
+    ocr: "ocr",
+};
+/**
+ * Device match criteria for device-specific config defaults.
+ * All specified criteria must match (AND logic).
+ */
+export const deviceMatchSchema = z.object({
+    /** Platform to match: "android" or "ios" */
+    platform: runtimeContextSchema.shape.platform,
+    /** Device brand to match (case-insensitive exact match, e.g., "google", "samsung") */
+    deviceBrand: z.string().optional(),
+    /** Device model prefix to match (e.g., "Pixel 10" matches "Pixel 10 Pro") */
+    deviceModelPrefix: z.string().optional(),
+    /** Device model substring to match (e.g., "Galaxy" matches "Samsung Galaxy S25") */
+    deviceModelContains: z.string().optional(),
+});
+/**
+ * Device-specific model config defaults.
+ * Accepts both canonical keys (e.g., "llamacpp-completion") and alias keys (e.g., "llm").
+ * NMT and TTS use passthrough since they don't have device-relevant config.
+ */
+export const deviceConfigDefaultsSchema = z
+    .object({
+    // Canonical keys
+    [ModelType.llamacppCompletion]: llmConfigBaseSchema.optional(),
+    [ModelType.llamacppEmbedding]: embedConfigBaseSchema.optional(),
+    [ModelType.whispercppTranscription]: whisperConfigSchema
+        .partial()
+        .optional(),
+    [ModelType.nmtcppTranslation]: z.record(z.string(), z.unknown()).optional(),
+    [ModelType.onnxTts]: z.record(z.string(), z.unknown()).optional(),
+    [ModelType.onnxOcr]: ocrConfigSchema.partial().optional(),
+    // Alias keys (user-friendly)
+    [AliasKeys.llm]: llmConfigBaseSchema.optional(),
+    [AliasKeys.embeddings]: embedConfigBaseSchema.optional(),
+    [AliasKeys.whisper]: whisperConfigSchema.partial().optional(),
+    [AliasKeys.nmt]: z.record(z.string(), z.unknown()).optional(),
+    [AliasKeys.tts]: z.record(z.string(), z.unknown()).optional(),
+    [AliasKeys.ocr]: ocrConfigSchema.partial().optional(),
+})
+    .partial();
+/**
+ * A device pattern rule for applying config defaults.
+ */
+export const devicePatternSchema = z.object({
+    /** Human-readable name for this pattern (used in logs) */
+    name: z.string(),
+    /** Match criteria - all specified fields must match */
+    match: deviceMatchSchema,
+    /** Config defaults to apply when matched */
+    defaults: deviceConfigDefaultsSchema,
+});
+const directoryPath = z.string().transform((s) => s.replace(/\/+$/, ""));
 /**
  * QVAC SDK Configuration Schema
  *
@@ -12,7 +77,7 @@ export const qvacConfigSchema = z.object({
      * Absolute path to the directory where models and other cached assets are stored.
      * If not specified, defaults to ~/.qvac/models
      */
-    cacheDirectory: z.string().optional(),
+    cacheDirectory: directoryPath.optional(),
     /**
      * Array of Hyperswarm relay public keys (hex strings) for improved P2P connectivity.
      * Blind relays help with NAT traversal and firewall bypassing.
@@ -30,4 +95,37 @@ export const qvacConfigSchema = z.object({
      * Defaults to true.
      */
     loggerConsoleOutput: z.boolean().optional(),
+    /**
+     * Maximum number of concurrent HTTP downloads for sharded models.
+     * Higher values may improve download speed but increase memory usage.
+     * Defaults to 3.
+     */
+    httpDownloadConcurrency: z.number().int().positive().optional(),
+    /**
+     * Timeout in milliseconds for HTTP connection establishment.
+     * This applies to HEAD and GET requests.
+     * If the connection is not established within this time, the request fails.
+     * Defaults to 10000 (10 seconds).
+     */
+    httpConnectionTimeoutMs: z.number().int().positive().optional(),
+    /**
+     * Device-specific config defaults.
+     * Use this to override model config defaults for specific devices.
+     * User-defined patterns are checked before SDK built-in patterns.
+     * First matching pattern wins.
+     *
+     * @example
+     * ```json
+     * {
+     *   "deviceDefaults": [
+     *     {
+     *       "name": "Custom Samsung",
+     *       "match": { "platform": "android", "deviceBrand": "samsung" },
+     *       "defaults": { "llm": { "device": "cpu" } }
+     *     }
+     *   ]
+     * }
+     * ```
+     */
+    deviceDefaults: z.array(devicePatternSchema).optional(),
 });

package/dist/schemas/sdk-errors-client.d.ts

@@ -7,6 +7,7 @@ export declare const SDK_CLIENT_ERROR_CODES: {
     readonly INVALID_AUDIO_CHUNK_TYPE: 50005;
     readonly INVALID_TOOLS_ARRAY: 50006;
     readonly INVALID_TOOL_SCHEMA: 50007;
+    readonly OCR_FAILED: 50008;
     readonly RPC_NO_HANDLER: 50200;
     readonly RPC_REQUEST_NOT_SENT: 50201;
     readonly RPC_RESPONSE_STREAM_NOT_CREATED: 50202;

package/dist/schemas/sdk-errors-client.js

@@ -9,6 +9,7 @@ export const SDK_CLIENT_ERROR_CODES = {
     INVALID_AUDIO_CHUNK_TYPE: 50005,
     INVALID_TOOLS_ARRAY: 50006,
     INVALID_TOOL_SCHEMA: 50007,
+    OCR_FAILED: 50008,
     // RPC Communication Errors (50,200-50,399)
     RPC_NO_HANDLER: 50200,
     RPC_REQUEST_NOT_SENT: 50201,
@@ -59,6 +60,10 @@ const clientErrorDefinitions = {
         name: "INVALID_TOOL_SCHEMA",
         message: (details) => `Invalid tool schema: ${details}`,
     },
+    [SDK_CLIENT_ERROR_CODES.OCR_FAILED]: {
+        name: "OCR_FAILED",
+        message: (details) => `OCR operation failed${details ? `: ${details}` : ""}`,
+    },
     // RPC Communication Errors (50,200-50,399)
     [SDK_CLIENT_ERROR_CODES.RPC_NO_HANDLER]: {
         name: "RPC_NO_HANDLER",

package/dist/schemas/sdk-errors-server.d.ts

@@ -25,12 +25,21 @@ export declare const SDK_SERVER_ERROR_CODES: {
     readonly TEXT_TO_SPEECH_FAILED: 52409;
     readonly CONFIG_RELOAD_NOT_SUPPORTED: 52410;
     readonly MODEL_TYPE_MISMATCH: 52411;
+    readonly OCR_FAILED: 52412;
+    readonly IMAGE_FILE_NOT_FOUND: 52413;
+    readonly INVALID_IMAGE_INPUT: 52414;
     readonly RAG_SAVE_FAILED: 52800;
     readonly RAG_SEARCH_FAILED: 52801;
     readonly RAG_DELETE_FAILED: 52802;
     readonly RAG_UNKNOWN_OPERATION: 52803;
     readonly RAG_HYPERDB_FAILED: 52804;
     readonly RAG_WORKSPACE_MODEL_MISMATCH: 52805;
+    readonly RAG_WORKSPACE_NOT_FOUND: 52806;
+    readonly RAG_WORKSPACE_IN_USE: 52807;
+    readonly RAG_WORKSPACE_CLOSE_FAILED: 52808;
+    readonly RAG_LIST_WORKSPACES_FAILED: 52809;
+    readonly RAG_CHUNK_FAILED: 52810;
+    readonly RAG_WORKSPACE_NOT_OPEN: 52811;
     readonly FILE_NOT_FOUND: 53000;
     readonly DOWNLOAD_CANCELLED: 53001;
     readonly CHECKSUM_VALIDATION_FAILED: 53002;
@@ -41,6 +50,11 @@ export declare const SDK_SERVER_ERROR_CODES: {
     readonly DOWNLOAD_ASSET_FAILED: 53007;
     readonly SEEDING_NOT_SUPPORTED: 53008;
     readonly HYPERDRIVE_DOWNLOAD_FAILED: 53009;
+    readonly INVALID_SHARD_URL_PATTERN: 53010;
+    readonly ARCHIVE_EXTRACTION_FAILED: 53011;
+    readonly ARCHIVE_UNSUPPORTED_TYPE: 53012;
+    readonly ARCHIVE_MISSING_SHARDS: 53013;
+    readonly PARTIAL_DOWNLOAD_OFFLINE: 53014;
     readonly DELETE_CACHE_FAILED: 53200;
     readonly INVALID_DELETE_CACHE_PARAMS: 53201;
     readonly CACHE_DIR_NOT_ABSOLUTE: 53202;

package/dist/schemas/sdk-errors-server.js

@@ -29,6 +29,9 @@ export const SDK_SERVER_ERROR_CODES = {
     TEXT_TO_SPEECH_FAILED: 52409,
     CONFIG_RELOAD_NOT_SUPPORTED: 52410,
     MODEL_TYPE_MISMATCH: 52411,
+    OCR_FAILED: 52412,
+    IMAGE_FILE_NOT_FOUND: 52413,
+    INVALID_IMAGE_INPUT: 52414,
     // RAG Operations (52,800-52,999)
     RAG_SAVE_FAILED: 52800,
     RAG_SEARCH_FAILED: 52801,
@@ -36,6 +39,12 @@ export const SDK_SERVER_ERROR_CODES = {
     RAG_UNKNOWN_OPERATION: 52803,
     RAG_HYPERDB_FAILED: 52804,
     RAG_WORKSPACE_MODEL_MISMATCH: 52805,
+    RAG_WORKSPACE_NOT_FOUND: 52806,
+    RAG_WORKSPACE_IN_USE: 52807,
+    RAG_WORKSPACE_CLOSE_FAILED: 52808,
+    RAG_LIST_WORKSPACES_FAILED: 52809,
+    RAG_CHUNK_FAILED: 52810,
+    RAG_WORKSPACE_NOT_OPEN: 52811,
     // Download/Resource Errors (53,000-53,199)
     FILE_NOT_FOUND: 53000,
     DOWNLOAD_CANCELLED: 53001,
@@ -47,6 +56,11 @@ export const SDK_SERVER_ERROR_CODES = {
     DOWNLOAD_ASSET_FAILED: 53007,
     SEEDING_NOT_SUPPORTED: 53008,
     HYPERDRIVE_DOWNLOAD_FAILED: 53009,
+    INVALID_SHARD_URL_PATTERN: 53010,
+    ARCHIVE_EXTRACTION_FAILED: 53011,
+    ARCHIVE_UNSUPPORTED_TYPE: 53012,
+    ARCHIVE_MISSING_SHARDS: 53013,
+    PARTIAL_DOWNLOAD_OFFLINE: 53014,
     // Cache Operations (53,200-53,349)
     DELETE_CACHE_FAILED: 53200,
     INVALID_DELETE_CACHE_PARAMS: 53201,
@@ -167,6 +181,18 @@ const serverErrorDefinitions = {
         name: "MODEL_TYPE_MISMATCH",
         message: (expectedType, providedType) => `Model type mismatch: expected "${expectedType}", got "${providedType}"`,
     },
+    [SDK_SERVER_ERROR_CODES.OCR_FAILED]: {
+        name: "OCR_FAILED",
+        message: (details) => `OCR operation failed${details ? `: ${details}` : ""}`,
+    },
+    [SDK_SERVER_ERROR_CODES.IMAGE_FILE_NOT_FOUND]: {
+        name: "IMAGE_FILE_NOT_FOUND",
+        message: (filePath) => `Image file not found or not accessible: ${filePath}`,
+    },
+    [SDK_SERVER_ERROR_CODES.INVALID_IMAGE_INPUT]: {
+        name: "INVALID_IMAGE_INPUT",
+        message: "Invalid image input type provided",
+    },
     // RAG Operations (52,800-52,999)
     [SDK_SERVER_ERROR_CODES.RAG_SAVE_FAILED]: {
         name: "RAG_SAVE_FAILED",
@@ -192,6 +218,30 @@ const serverErrorDefinitions = {
         name: "RAG_WORKSPACE_MODEL_MISMATCH",
         message: (workspace, existingModelId, newModelId) => `Workspace "${workspace}" is configured for model "${existingModelId}", but you're trying to use model "${newModelId}". Use a different workspace or the same model`,
     },
+    [SDK_SERVER_ERROR_CODES.RAG_WORKSPACE_NOT_FOUND]: {
+        name: "RAG_WORKSPACE_NOT_FOUND",
+        message: (workspace) => `RAG workspace not found: ${workspace}`,
+    },
+    [SDK_SERVER_ERROR_CODES.RAG_WORKSPACE_IN_USE]: {
+        name: "RAG_WORKSPACE_IN_USE",
+        message: (workspace) => `RAG workspace '${workspace}' is currently in use. Close it first.`,
+    },
+    [SDK_SERVER_ERROR_CODES.RAG_WORKSPACE_CLOSE_FAILED]: {
+        name: "RAG_WORKSPACE_CLOSE_FAILED",
+        message: (details) => `Failed to close RAG workspace${details ? `: ${details}` : ""}`,
+    },
+    [SDK_SERVER_ERROR_CODES.RAG_LIST_WORKSPACES_FAILED]: {
+        name: "RAG_LIST_WORKSPACES_FAILED",
+        message: (details) => `Failed to list RAG workspaces${details ? `: ${details}` : ""}`,
+    },
+    [SDK_SERVER_ERROR_CODES.RAG_CHUNK_FAILED]: {
+        name: "RAG_CHUNK_FAILED",
+        message: (details) => `Failed to chunk documents${details ? `: ${details}` : ""}`,
+    },
+    [SDK_SERVER_ERROR_CODES.RAG_WORKSPACE_NOT_OPEN]: {
+        name: "RAG_WORKSPACE_NOT_OPEN",
+        message: (workspace) => `RAG workspace '${workspace}' is not open`,
+    },
     // Download/Resource Errors (53,000-53,199)
     [SDK_SERVER_ERROR_CODES.FILE_NOT_FOUND]: {
         name: "FILE_NOT_FOUND",
@@ -233,6 +283,26 @@ const serverErrorDefinitions = {
         name: "HYPERDRIVE_DOWNLOAD_FAILED",
         message: (details) => `Hyperdrive download failed: ${details}`,
     },
+    [SDK_SERVER_ERROR_CODES.INVALID_SHARD_URL_PATTERN]: {
+        name: "INVALID_SHARD_URL_PATTERN",
+        message: (url) => `URL does not contain a valid sharded model pattern: ${url}`,
+    },
+    [SDK_SERVER_ERROR_CODES.ARCHIVE_EXTRACTION_FAILED]: {
+        name: "ARCHIVE_EXTRACTION_FAILED",
+        message: (archivePath) => `Failed to extract archive: ${archivePath}`,
+    },
+    [SDK_SERVER_ERROR_CODES.ARCHIVE_UNSUPPORTED_TYPE]: {
+        name: "ARCHIVE_UNSUPPORTED_TYPE",
+        message: (archivePath) => `Unsupported archive type: ${archivePath}`,
+    },
+    [SDK_SERVER_ERROR_CODES.ARCHIVE_MISSING_SHARDS]: {
+        name: "ARCHIVE_MISSING_SHARDS",
+        message: (missingFile) => `Archive is missing required shard file: ${missingFile}`,
+    },
+    [SDK_SERVER_ERROR_CODES.PARTIAL_DOWNLOAD_OFFLINE]: {
+        name: "PARTIAL_DOWNLOAD_OFFLINE",
+        message: (url, downloadedBytes) => `Cannot resume partial download (${downloadedBytes} bytes downloaded) - unable to connect. URL: ${url}`,
+    },
     // Cache Operations (53,200-53,349)
     [SDK_SERVER_ERROR_CODES.DELETE_CACHE_FAILED]: {
         name: "DELETE_CACHE_FAILED",

package/dist/schemas/shard.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const shardFileMetadataSchema: z.ZodObject<{
+    filename: z.ZodString;
+    expectedSize: z.ZodNumber;
+    sha256Checksum: z.ZodString;
+}, z.core.$strip>;
+export declare const shardUrlSchema: z.ZodObject<{
+    url: z.ZodURL;
+    filename: z.ZodString;
+}, z.core.$strip>;
+export declare const shardPatternInfoSchema: z.ZodObject<{
+    isSharded: z.ZodBoolean;
+    currentShard: z.ZodOptional<z.ZodNumber>;
+    totalShards: z.ZodOptional<z.ZodNumber>;
+    baseFilename: z.ZodOptional<z.ZodString>;
+    extension: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ShardFileMetadata = z.infer<typeof shardFileMetadataSchema>;
+export type ShardUrl = z.infer<typeof shardUrlSchema>;
+export type ShardPatternInfo = z.infer<typeof shardPatternInfoSchema>;
+//# sourceMappingURL=shard.d.ts.map

package/dist/schemas/shard.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export const shardFileMetadataSchema = z.object({
+    filename: z.string(),
+    expectedSize: z.number(),
+    sha256Checksum: z.string(),
+});
+export const shardUrlSchema = z.object({
+    url: z.url(),
+    filename: z.string(),
+});
+export const shardPatternInfoSchema = z.object({
+    isSharded: z.boolean(),
+    currentShard: z.number().optional(),
+    totalShards: z.number().optional(),
+    baseFilename: z.string().optional(),
+    extension: z.string().optional(),
+});

package/dist/schemas/translate.d.ts

@@ -1,58 +1,98 @@
 import { z } from "zod";
 import type { NmtLanguage } from "./translation-config";
-declare const translateParamsBaseSchema: z.ZodObject<{
+import { type NmtModelTypeInput, type LlmModelTypeInput } from "./model-types";
+declare const translateParamsSchema: z.ZodUnion<readonly [z.ZodObject<{
     modelId: z.ZodString;
-    text: z.ZodString;
-    stream: z.ZodBoolean;
-}, z.core.$strip>;
-declare const translateParamsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    modelId: z.ZodString;
-    text: z.ZodString;
+    text: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
     stream: z.ZodBoolean;
-    modelType: z.ZodLiteral<"nmt">;
+    modelType: z.ZodEnum<{
+        "nmtcpp-translation": "nmtcpp-translation";
+        nmt: "nmt";
+    }>;
 }, z.core.$strip>, z.ZodObject<{
     modelId: z.ZodString;
     text: z.ZodString;
     stream: z.ZodBoolean;
-    modelType: z.ZodLiteral<"llm">;
+    modelType: z.ZodEnum<{
+        "llamacpp-completion": "llamacpp-completion";
+        llm: "llm";
+    }>;
     from: z.ZodOptional<z.ZodString>;
     to: z.ZodString;
     context: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>], "modelType">;
+}, z.core.$strip>]>;
 export declare const translationStatsSchema: z.ZodObject<{
     processedTokens: z.ZodNumber;
     processingTime: z.ZodNumber;
 }, z.core.$strip>;
 export declare const translateRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
     modelId: z.ZodString;
-    text: z.ZodString;
+    text: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
     stream: z.ZodBoolean;
-    modelType: z.ZodLiteral<"nmt">;
+    modelType: z.ZodEnum<{
+        "nmtcpp-translation": "nmtcpp-translation";
+        nmt: "nmt";
+    }>;
     type: z.ZodLiteral<"translate">;
 }, z.core.$strip>, z.ZodObject<{
     modelId: z.ZodString;
     text: z.ZodString;
     stream: z.ZodBoolean;
-    modelType: z.ZodLiteral<"llm">;
+    modelType: z.ZodEnum<{
+        "llamacpp-completion": "llamacpp-completion";
+        llm: "llm";
+    }>;
     from: z.ZodOptional<z.ZodString>;
     to: z.ZodString;
     context: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"translate">;
 }, z.core.$strip>]>;
-export declare const translateServerParamsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const translateServerParamsSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodObject<{
     modelId: z.ZodString;
-    text: z.ZodString;
+    text: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
     stream: z.ZodBoolean;
-    modelType: z.ZodLiteral<"nmt">;
+    modelType: z.ZodEnum<{
+        "nmtcpp-translation": "nmtcpp-translation";
+        nmt: "nmt";
+    }>;
 }, z.core.$strip>, z.ZodObject<{
     modelId: z.ZodString;
     text: z.ZodString;
     stream: z.ZodBoolean;
-    modelType: z.ZodLiteral<"llm">;
+    modelType: z.ZodEnum<{
+        "llamacpp-completion": "llamacpp-completion";
+        llm: "llm";
+    }>;
     from: z.ZodOptional<z.ZodString>;
     to: z.ZodString;
     context: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>], "modelType">;
+}, z.core.$strip>]>, z.ZodTransform<{
+    modelType: import("./model-types").CanonicalModelType;
+    modelId: string;
+    text: string | string[];
+    stream: boolean;
+} | {
+    modelType: import("./model-types").CanonicalModelType;
+    modelId: string;
+    text: string;
+    stream: boolean;
+    to: string;
+    from?: string | undefined;
+    context?: string | undefined;
+}, {
+    modelId: string;
+    text: string | string[];
+    stream: boolean;
+    modelType: "nmtcpp-translation" | "nmt";
+} | {
+    modelId: string;
+    text: string;
+    stream: boolean;
+    modelType: "llamacpp-completion" | "llm";
+    to: string;
+    from?: string | undefined;
+    context?: string | undefined;
+}>>;
 export declare const translateResponseSchema: z.ZodObject<{
     type: z.ZodLiteral<"translate">;
     token: z.ZodString;
@@ -67,12 +107,17 @@ export type TranslateParams = z.infer<typeof translateParamsSchema>;
 export type TranslateRequest = z.infer<typeof translateRequestSchema>;
 export type TranslateResponse = z.infer<typeof translateResponseSchema>;
 export type TranslationStats = z.infer<typeof translationStatsSchema>;
-type TranslateParamsBase = z.input<typeof translateParamsBaseSchema>;
-type TranslateParamsNmt = TranslateParamsBase & {
-    modelType: "nmt";
+type TranslateParamsNmt = {
+    modelId: string;
+    text: string | string[];
+    stream: boolean;
+    modelType: NmtModelTypeInput;
 };
-type TranslateParamsLlm = TranslateParamsBase & {
-    modelType: "llm";
+type TranslateParamsLlm = {
+    modelId: string;
+    text: string;
+    stream: boolean;
+    modelType: LlmModelTypeInput;
     from?: NmtLanguage | (string & {});
     to: NmtLanguage | (string & {});
     context?: string;

package/dist/schemas/translate.js

@@ -1,19 +1,27 @@
 import { z } from "zod";
-const translateParamsBaseSchema = z.object({
+import { nmtModelTypeSchema, llmModelTypeSchema, normalizeModelType, } from "./model-types.js";
+const translateParamsNmtSchema = z.object({
     modelId: z.string(),
-    text: z.string().min(1, "Text cannot be empty"),
+    text: z.union([
+        z.string().min(1, "Text cannot be empty"),
+        z
+            .array(z.string().min(1, "Text cannot be empty"))
+            .min(1, "Array cannot be empty"),
+    ]),
     stream: z.boolean(),
+    modelType: nmtModelTypeSchema,
 });
-const translateParamsNmtSchema = translateParamsBaseSchema.extend({
-    modelType: z.literal("nmt"),
-});
-const translateParamsLlmSchema = translateParamsBaseSchema.extend({
-    modelType: z.literal("llm"),
+const translateParamsLlmSchema = z.object({
+    modelId: z.string(),
+    text: z.string().min(1, "Text cannot be empty"),
+    stream: z.boolean(),
+    modelType: llmModelTypeSchema,
     from: z.string().optional(),
     to: z.string(),
     context: z.string().optional(),
 });
-const translateParamsSchema = z.discriminatedUnion("modelType", [
+// Using z.union since each modelType accepts multiple values
+const translateParamsSchema = z.union([
     translateParamsNmtSchema,
     translateParamsLlmSchema,
 ]);
@@ -25,14 +33,32 @@ export const translateRequestSchema = z.union([
     translateParamsNmtSchema.extend({ type: z.literal("translate") }),
     translateParamsLlmSchema.extend({ type: z.literal("translate") }),
 ]);
+// Valid model types for translation (aliases and canonical)
+const validTranslationModelTypes = [
+    "nmt",
+    "nmtcpp-translation",
+    "llm",
+    "llamacpp-completion",
+];
+const llmModelTypes = ["llm", "llamacpp-completion"];
 // Validates the translate server args and returns the model info
 export const translateServerParamsSchema = translateParamsSchema
-    .refine((data) => data.modelType && ["nmt", "llm"].includes(data.modelType), {
+    .refine((data) => data.modelType && validTranslationModelTypes.includes(data.modelType), {
     message: "Model type is not compatible with translation. Only LLM and NMT models are supported.",
 })
-    .refine((data) => !(data.modelType === "llm" && (!data.from || !data.to)), {
+    .refine((data) => {
+    if (!llmModelTypes.includes(data.modelType))
+        return true;
+    // For LLM, check from/to exist
+    const llmData = data;
+    return llmData.from && llmData.to;
+}, {
     message: "Both 'from' and 'to' languages are required for LLM translation models",
-});
+})
+    .transform((data) => ({
+    ...data,
+    modelType: normalizeModelType(data.modelType),
+}));
 export const translateResponseSchema = z.object({
     type: z.literal("translate"),
     token: z.string(),