@qvac/sdk 0.8.1 → 1.0.0

package/dist/schemas/load-model.js

@@ -1,318 +1,102 @@
 import { z } from "zod";
-import { llmConfigBaseSchema, embedConfigBaseSchema, } from "./llamacpp-config.js";
-import { whisperConfigSchema, parakeetConfigSchema, } from "./transcription-config.js";
+import { llmConfigSchema, embedConfigSchema } 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, parakeetModelTypeSchema, embeddingsModelTypeSchema, nmtModelTypeSchema, ttsModelTypeSchema, ocrModelTypeSchema, ModelType, ModelTypeAliases, } from "./model-types.js";
-// Set of all built-in model types (canonical + aliases) for catch-all exclusion
-const builtInModelTypes = new Set([
-    ...Object.values(ModelType),
-    ...Object.keys(ModelTypeAliases),
-]);
-import { reloadConfigRequestSchema } from "./reload-config.js";
-const loadModelCommonFields = {
-    modelSrc: modelSrcInputSchema,
-    seed: z.boolean().optional(),
-    delegate: delegateSchema,
-};
-const loadModelRequestCommonFields = {
-    ...loadModelCommonFields,
-    onProgress: z.unknown().optional(),
-    withProgress: z.boolean().optional(),
-};
-export const loadModelOptionsBaseSchema = z.union([
-    z
-        .object({
-        ...loadModelCommonFields,
-        modelType: llmModelTypeSchema,
-        modelConfig: llmConfigBaseSchema.strict().optional(),
-    })
-        .strict(),
-    z
-        .object({
-        ...loadModelCommonFields,
-        modelType: whisperModelTypeSchema,
+export const loadModelOptionsSchema = z
+    .union([
+    z.object({
+        modelSrc: z.string(),
+        modelType: z.literal("llm"),
+        modelConfig: llmConfigSchema.partial().strict().optional(),
+        seed: z.boolean().optional(),
+        projectionModelSrc: z.string().optional(),
+        delegate: delegateSchema,
+        toolFormat: z.enum(["json", "xml"]).default("json"),
+    }),
+    z.object({
+        modelSrc: z.string(),
+        modelType: z.literal("whisper"),
         modelConfig: whisperConfigSchema.partial().strict().optional(),
-    })
-        .strict(),
-    z
-        .object({
-        ...loadModelCommonFields,
-        modelType: parakeetModelTypeSchema,
-        modelConfig: parakeetConfigSchema,
-    })
-        .strict(),
-    z
-        .object({
-        ...loadModelCommonFields,
-        modelType: embeddingsModelTypeSchema,
-        modelConfig: embedConfigBaseSchema.strict().optional(),
-    })
-        .strict(),
-    z
-        .object({
-        ...loadModelCommonFields,
-        modelType: nmtModelTypeSchema,
+        seed: z.boolean().optional(),
+        vadModelSrc: z.string().optional(),
+        delegate: delegateSchema,
+    }),
+    z.object({
+        modelSrc: z.string(),
+        modelType: z.literal("embeddings"),
+        modelConfig: embedConfigSchema.partial().strict().optional(),
+        seed: z.boolean().optional(),
+        delegate: delegateSchema,
+    }),
+    z.object({
+        modelSrc: z.string(),
+        modelType: z.literal("nmt"),
         modelConfig: nmtConfigSchema,
-    })
-        .strict(),
-    z
-        .object({
-        ...loadModelCommonFields,
-        modelType: ttsModelTypeSchema,
-        modelConfig: ttsConfigSchema,
-    })
-        .strict(),
-    z
-        .object({
-        ...loadModelCommonFields,
-        modelType: ocrModelTypeSchema,
-        modelConfig: ocrConfigSchema.partial().strict().optional(),
-    })
-        .strict(),
-    // Custom plugin catch-all: accepts any modelType string EXCEPT built-ins
+        seed: z.boolean().optional(),
+        delegate: delegateSchema,
+    }),
     z.object({
-        ...loadModelCommonFields,
-        modelType: z.string().refine((val) => !builtInModelTypes.has(val), {
-            message: "Built-in model types must use their specific schema",
-        }),
-        modelConfig: z.record(z.string(), z.unknown()).optional(),
+        modelSrc: z.string(),
+        modelType: z.literal("tts"),
+        modelConfig: ttsConfigSchema,
+        configSrc: z.string(),
+        eSpeakDataPath: z.string(),
+        seed: z.boolean().optional(),
+        delegate: delegateSchema,
     }),
-]);
-export const loadModelOptionsSchema = loadModelOptionsBaseSchema.transform((data) => ({
+])
+    .transform((data) => ({
     ...data,
     seed: data.seed ?? false,
 }));
-const loadModelOptionsToRequestBaseSchema = z.union([
-    z
-        .object({
-        ...loadModelRequestCommonFields,
-        modelType: llmModelTypeSchema,
-        modelConfig: llmConfigBaseSchema.strict().optional(),
-    })
-        .strict()
-        .transform((data) => ({
-        type: "loadModel",
-        modelType: ModelType.llamacppCompletion,
-        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,
-    })),
-    z
-        .object({
-        ...loadModelRequestCommonFields,
-        modelType: whisperModelTypeSchema,
-        modelConfig: whisperConfigSchema.partial().strict().optional(),
-    })
-        .strict()
-        .transform((data) => ({
-        type: "loadModel",
-        modelType: ModelType.whispercppTranscription,
-        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,
-    })),
-    z
-        .object({
-        ...loadModelRequestCommonFields,
-        modelType: parakeetModelTypeSchema,
-        modelConfig: parakeetConfigSchema,
-    })
-        .strict()
-        .transform((data) => ({
-        type: "loadModel",
-        modelType: ModelType.parakeetTranscription,
-        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,
-    })),
-    z
-        .object({
-        ...loadModelRequestCommonFields,
-        modelType: embeddingsModelTypeSchema,
-        modelConfig: embedConfigBaseSchema.strict().optional(),
-    })
-        .strict()
-        .transform((data) => ({
-        type: "loadModel",
-        modelType: ModelType.llamacppEmbedding,
-        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,
-    })),
-    z
-        .object({
-        ...loadModelRequestCommonFields,
-        modelType: nmtModelTypeSchema,
-        modelConfig: nmtConfigSchema,
-    })
-        .strict()
-        .transform((data) => ({
-        type: "loadModel",
-        modelType: ModelType.nmtcppTranslation,
-        modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
-        modelName: modelInputToNameSchema.parse(data.modelSrc),
-        modelConfig: (data.modelConfig.engine === "Bergamot" && data.modelConfig.pivotModel) ? {
-            ...data.modelConfig,
-            pivotModel: {
-                ...data.modelConfig.pivotModel,
-                modelSrc: modelInputToSrcSchema.parse(data.modelConfig.pivotModel.modelSrc),
-            },
-        } : data.modelConfig,
-        seed: data.seed ?? false,
-        withProgress: data.withProgress ?? !!data.onProgress,
-        delegate: data.delegate,
-    })),
-    z
-        .object({
-        ...loadModelRequestCommonFields,
-        modelType: ttsModelTypeSchema,
-        modelConfig: ttsConfigSchema,
-    })
-        .strict()
-        .transform((data) => ({
-        type: "loadModel",
-        modelType: ModelType.onnxTts,
-        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,
-    })),
-    z
-        .object({
-        ...loadModelRequestCommonFields,
-        modelType: ocrModelTypeSchema,
-        modelConfig: ocrConfigSchema.partial().strict().optional(),
-    })
-        .strict()
-        .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,
-    })),
-    z
-        .object({
-        ...loadModelRequestCommonFields,
-        modelType: z.string().refine((val) => !builtInModelTypes.has(val), {
-            message: "Built-in model types must use their specific schema",
-        }),
-        modelConfig: z.record(z.string(), z.unknown()).optional(),
-    })
-        .transform((data) => ({
-        type: "loadModel",
-        modelType: data.modelType,
-        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,
-    })),
-]);
-export const loadModelOptionsToRequestSchema = loadModelOptionsToRequestBaseSchema;
 const commonModelConfigSchema = z.object({
     type: z.literal("loadModel"),
     modelSrc: z.string(),
-    modelName: z.string().optional(),
+    projectionModelSrc: z.string().optional(),
+    vadModelSrc: z.string().optional(),
+    configSrc: z.string().optional(),
     withProgress: z.boolean().optional(),
     seed: z.boolean().optional(),
     delegate: delegateSchema,
 });
-// 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(ModelType.llamacppCompletion),
-    modelConfig: llmConfigBaseSchema,
-})
-    .strict();
-export const loadWhisperModelRequestSchema = commonModelConfigSchema
-    .extend({
-    modelType: z.literal(ModelType.whispercppTranscription),
+// Request schemas for each model type
+export const loadLlmModelRequestSchema = commonModelConfigSchema.extend({
+    modelType: z.literal("llm"),
+    modelConfig: llmConfigSchema,
+});
+export const loadWhisperModelRequestSchema = commonModelConfigSchema.extend({
+    modelType: z.literal("whisper"),
     modelConfig: whisperConfigSchema,
-})
-    .strict();
-export const loadParakeetModelRequestSchema = commonModelConfigSchema
-    .extend({
-    modelType: z.literal(ModelType.parakeetTranscription),
-    modelConfig: parakeetConfigSchema,
-})
-    .strict();
-export const loadEmbeddingsModelRequestSchema = commonModelConfigSchema
-    .extend({
-    modelType: z.literal(ModelType.llamacppEmbedding),
-    modelConfig: embedConfigBaseSchema,
-})
-    .strict();
-export const loadNmtModelRequestSchema = commonModelConfigSchema
-    .extend({
-    modelType: z.literal(ModelType.nmtcppTranslation),
+});
+export const loadEmbeddingsModelRequestSchema = commonModelConfigSchema.extend({
+    modelType: z.literal("embeddings"),
+    modelConfig: embedConfigSchema,
+});
+export const loadNmtModelRequestSchema = commonModelConfigSchema.extend({
+    modelType: z.literal("nmt"),
     modelConfig: nmtConfigSchema,
-})
-    .strict();
-export const loadTtsModelRequestSchema = commonModelConfigSchema
-    .extend({
-    modelType: z.literal(ModelType.onnxTts),
+});
+export const loadTtsModelRequestSchema = commonModelConfigSchema.extend({
+    modelType: z.literal("tts"),
     modelConfig: ttsConfigSchema,
-})
-    .strict();
-export const loadOcrModelRequestSchema = commonModelConfigSchema
-    .extend({
-    modelType: z.literal(ModelType.onnxOcr),
-    modelConfig: ocrConfigSchema,
-})
-    .strict();
-// Custom plugin catch-all: accepts any modelType string EXCEPT built-ins
-export const loadCustomPluginModelRequestSchema = commonModelConfigSchema.extend({
-    modelType: z.string().refine((val) => !builtInModelTypes.has(val), {
-        message: "Built-in model types must use their specific schema",
-    }),
-    modelConfig: z.record(z.string(), z.unknown()).optional(),
+    configSrc: z.string(),
+    eSpeakDataPath: z.string(),
 });
-// Union of all load model request types (using z.union since each modelType accepts multiple values)
-export const loadModelSrcRequestSchema = z
-    .union([
+// Union of all load model request types
+export const loadModelRequestSchema = z
+    .discriminatedUnion("modelType", [
     loadLlmModelRequestSchema,
     loadWhisperModelRequestSchema,
-    loadParakeetModelRequestSchema,
     loadEmbeddingsModelRequestSchema,
     loadNmtModelRequestSchema,
     loadTtsModelRequestSchema,
-    loadOcrModelRequestSchema,
-    loadCustomPluginModelRequestSchema,
 ])
     .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(),
@@ -325,26 +109,6 @@ export const modelProgressUpdateSchema = z.object({
     total: z.number(),
     percentage: z.number(),
     downloadKey: z.string(),
-    shardInfo: z
-        .object({
-        currentShard: z.number(),
-        totalShards: z.number(),
-        shardName: z.string(),
-        overallDownloaded: z.number(),
-        overallTotal: z.number(),
-        overallPercentage: z.number(),
-    })
-        .optional(),
-    onnxInfo: z
-        .object({
-        currentFile: z.string(),
-        fileIndex: z.number(),
-        totalFiles: z.number(),
-        overallDownloaded: z.number(),
-        overallTotal: z.number(),
-        overallPercentage: z.number(),
-    })
-        .optional(),
 });
 export const hyperdriveUrlSchema = z
     .string()
@@ -353,29 +117,12 @@ export const hyperdriveUrlSchema = z
     const match = url.match(/^pear:\/\/([0-9a-fA-F]{64})\/(.+)$/);
     return { key: match[1], path: match[2] };
 });
-/**
- * Schema for registry:// URLs (internal use only).
- * Users should use model constants from @qvac/sdk instead of raw URLs.
- * Format: registry://source/path/to/model.gguf
- */
-export const registryUrlSchema = z
-    .string()
-    .regex(/^registry:\/\/([^/]+)\/(.+)$/, "Invalid registry URL. Expected format: registry://source/path/to/model.gguf")
-    .transform((url) => {
-    const match = url.match(/^registry:\/\/([^/]+)\/(.+)$/);
-    return {
-        registrySource: match[1],
-        registryPath: match[2], // Path without source prefix
-    };
-});
-const loadModelServerOptionsSchema = commonModelConfigSchema.extend({
-    modelType: z.string(),
-    modelConfig: z.record(z.string(), z.unknown()).optional(),
-});
 export const loadModelServerParamsSchema = z.object({
     modelId: z.string(),
     modelPath: z.string(),
-    options: loadModelServerOptionsSchema,
-    artifacts: z.record(z.string(), z.string()).optional(),
-    modelName: z.string().optional(),
+    options: loadModelOptionsSchema,
+    projectionModelPath: z.string().optional(),
+    vadModelPath: z.string().optional(),
+    ttsConfigModelPath: z.string().optional(),
+    eSpeakDataPath: z.string().optional(),
 });

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

@@ -1,27 +1,20 @@
 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<{
-    id: z.ZodString;
+    modelId: z.ZodString;
 }, z.core.$strip>;
 export declare const loggingStreamRequestSchema: z.ZodObject<{
-    id: z.ZodString;
+    modelId: z.ZodString;
     type: z.ZodLiteral<"loggingStream">;
 }, z.core.$strip>;
 export declare const loggingStreamResponseSchema: z.ZodObject<{
     type: z.ZodLiteral<"loggingStream">;
-    id: z.ZodString;
+    modelId: 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,16 +1,15 @@
 import { z } from "zod";
 const logLevelValues = ["error", "warn", "info", "debug"];
-export const logLevelSchema = z.enum(logLevelValues);
 const loggingParamsSchema = z.object({
-    id: z.string(),
+    modelId: z.string(),
 });
 export const loggingStreamRequestSchema = loggingParamsSchema.extend({
     type: z.literal("loggingStream"),
 });
 export const loggingStreamResponseSchema = z.object({
     type: z.literal("loggingStream"),
-    id: z.string(),
-    level: logLevelSchema,
+    modelId: z.string(),
+    level: z.enum(logLevelValues),
     namespace: z.string(),
     message: z.string(),
     timestamp: z.number(),

package/dist/schemas/ping.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const pingRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"ping">;
+}, z.core.$strip>;
+export declare const pingResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"pong">;
+    number: z.ZodNumber;
+}, z.core.$strip>;
+export type PingRequest = z.infer<typeof pingRequestSchema>;
+export type PingResponse = z.infer<typeof pingResponseSchema>;
+//# sourceMappingURL=ping.d.ts.map

package/dist/schemas/ping.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export const pingRequestSchema = z.object({
+    type: z.literal("ping"),
+});
+export const pingResponseSchema = z.object({
+    type: z.literal("pong"),
+    number: z.number(),
+});