@qvac/sdk 0.8.1 → 1.0.0

package/dist/schemas/text-to-speech.js

@@ -1,5 +1,4 @@
 import { z } from "zod";
-import { modelSrcInputSchema } from "./model-src-utils.js";
 // TTS supported languages based on available models
 export const TTS_LANGUAGES = [
     "en", // English
@@ -7,44 +6,13 @@ export const TTS_LANGUAGES = [
     "de", // German
     "it", // Italian
 ];
-const ttsLanguageSchema = z.enum(TTS_LANGUAGES);
-export const ttsChatterboxRuntimeConfigSchema = z.object({
-    ttsEngine: z.literal("chatterbox"),
-    language: ttsLanguageSchema,
+export const ttsConfigSchema = z.object({
+    language: z.enum(TTS_LANGUAGES),
 });
-export const ttsSupertonicRuntimeConfigSchema = z.object({
-    ttsEngine: z.literal("supertonic"),
-    language: ttsLanguageSchema,
-    ttsSpeed: z.number().optional(),
-    ttsNumInferenceSteps: z.number().optional(),
-});
-export const ttsRuntimeConfigSchema = z.union([
-    ttsChatterboxRuntimeConfigSchema,
-    ttsSupertonicRuntimeConfigSchema,
-]);
-export const ttsChatterboxConfigSchema = ttsChatterboxRuntimeConfigSchema.extend({
-    ttsTokenizerSrc: modelSrcInputSchema,
-    ttsSpeechEncoderSrc: modelSrcInputSchema,
-    ttsEmbedTokensSrc: modelSrcInputSchema,
-    ttsConditionalDecoderSrc: modelSrcInputSchema,
-    ttsLanguageModelSrc: modelSrcInputSchema,
-    referenceAudioSrc: modelSrcInputSchema,
-});
-export const ttsSupertonicConfigSchema = ttsSupertonicRuntimeConfigSchema.extend({
-    ttsTokenizerSrc: modelSrcInputSchema,
-    ttsTextEncoderSrc: modelSrcInputSchema,
-    ttsLatentDenoiserSrc: modelSrcInputSchema,
-    ttsVoiceDecoderSrc: modelSrcInputSchema,
-    ttsVoiceSrc: modelSrcInputSchema,
-});
-export const ttsConfigSchema = z.union([
-    ttsChatterboxConfigSchema,
-    ttsSupertonicConfigSchema,
-]);
 export const ttsClientParamsSchema = z.object({
     modelId: z.string(),
     inputType: z.string().default("text"),
-    text: z.string().trim().min(1, "text must not be empty or whitespace-only"),
+    text: z.string(),
     stream: z.boolean().default(true),
 });
 export const ttsRequestSchema = ttsClientParamsSchema.extend({

package/dist/schemas/transcription.d.ts

@@ -15,7 +15,6 @@ export declare const transcribeParamsSchema: z.ZodObject<{
         type: z.ZodLiteral<"filePath">;
         value: z.ZodString;
     }, z.core.$strip>], "type">;
-    prompt: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const transcribeStreamRequestSchema: z.ZodObject<{
     modelId: z.ZodString;
@@ -26,7 +25,6 @@ export declare const transcribeStreamRequestSchema: z.ZodObject<{
         type: z.ZodLiteral<"filePath">;
         value: z.ZodString;
     }, z.core.$strip>], "type">;
-    prompt: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"transcribeStream">;
 }, z.core.$strip>;
 export declare const transcribeStreamResponseSchema: z.ZodObject<{
@@ -40,7 +38,6 @@ export type TranscribeParams = z.infer<typeof transcribeParamsSchema>;
 export type TranscribeClientParams = {
     modelId: string;
     audioChunk: string | Buffer;
-    prompt?: string;
 };
 export type TranscribeStreamRequest = z.infer<typeof transcribeStreamRequestSchema>;
 export type TranscribeStreamResponse = z.infer<typeof transcribeStreamResponseSchema>;

package/dist/schemas/transcription.js

@@ -12,7 +12,6 @@ export const audioInputSchema = z.discriminatedUnion("type", [
 export const transcribeParamsSchema = z.object({
     modelId: z.string(),
     audioChunk: audioInputSchema,
-    prompt: z.string().optional(),
 });
 // Streaming Transcribe Schema (for real-time audio streaming)
 export const transcribeStreamRequestSchema = transcribeParamsSchema.extend({

package/dist/schemas/translate.d.ts

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

package/dist/schemas/translate.js

@@ -1,27 +1,19 @@
 import { z } from "zod";
-import { nmtModelTypeSchema, llmModelTypeSchema, normalizeModelType, } from "./model-types.js";
-const translateParamsNmtSchema = z.object({
-    modelId: z.string(),
-    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 translateParamsLlmSchema = z.object({
+const translateParamsBaseSchema = z.object({
     modelId: z.string(),
     text: z.string().min(1, "Text cannot be empty"),
     stream: z.boolean(),
-    modelType: llmModelTypeSchema,
+});
+const translateParamsNmtSchema = translateParamsBaseSchema.extend({
+    modelType: z.literal("nmt"),
+});
+const translateParamsLlmSchema = translateParamsBaseSchema.extend({
+    modelType: z.literal("llm"),
     from: z.string().optional(),
     to: z.string(),
     context: z.string().optional(),
 });
-// Using z.union since each modelType accepts multiple values
-const translateParamsSchema = z.union([
+const translateParamsSchema = z.discriminatedUnion("modelType", [
     translateParamsNmtSchema,
     translateParamsLlmSchema,
 ]);
@@ -33,32 +25,14 @@ 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 && validTranslationModelTypes.includes(data.modelType), {
+    .refine((data) => data.modelType && ["nmt", "llm"].includes(data.modelType), {
     message: "Model type is not compatible with translation. Only LLM and NMT models are supported.",
 })
-    .refine((data) => {
-    if (!llmModelTypes.includes(data.modelType))
-        return true;
-    // For LLM, check from/to exist
-    const llmData = data;
-    return llmData.from && llmData.to;
-}, {
+    .refine((data) => !(data.modelType === "llm" && (!data.from || !data.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(),