@qvac/sdk 0.14.1 → 0.16.0

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

@@ -1,98 +1,103 @@
-import { z } from "zod";
-import { modelSrcInputSchema } from "./model-src-utils.js";
-// Chatterbox multilingual supported languages (22). The engines support
+import { z } from 'zod';
+import { modelSrcInputSchema } from './model-src-utils.js';
+// Chatterbox multilingual supported languages (23). The engines support
 // different language sets, so the language enum is validated per engine.
 export const TTS_CHATTERBOX_LANGUAGES = [
-    "en", // English
-    "es", // Spanish
-    "fr", // French
-    "de", // German
-    "it", // Italian
-    "pt", // Portuguese
-    "nl", // Dutch
-    "pl", // Polish
-    "tr", // Turkish
-    "sv", // Swedish
-    "da", // Danish
-    "fi", // Finnish
-    "no", // Norwegian
-    "el", // Greek
-    "ms", // Malay
-    "sw", // Swahili
-    "ar", // Arabic
-    "ko", // Korean
-    "he", // Hebrew
-    "ru", // Russian
-    "zh", // Chinese
-    "hi", // Hindi
+    'en', // English
+    'es', // Spanish
+    'fr', // French
+    'de', // German
+    'it', // Italian
+    'ja', // Japanese
+    'pt', // Portuguese
+    'nl', // Dutch
+    'pl', // Polish
+    'tr', // Turkish
+    'sv', // Swedish
+    'da', // Danish
+    'fi', // Finnish
+    'no', // Norwegian
+    'el', // Greek
+    'ms', // Malay
+    'sw', // Swahili
+    'ar', // Arabic
+    'ko', // Korean
+    'he', // Hebrew
+    'ru', // Russian
+    'zh', // Chinese
+    'hi' // Hindi
 ];
 // Supertonic supported languages (31, as of Supertonic 3). Earlier Supertonic
 // releases (1/2) only cover a subset, but validation is per-engine, not
 // per-model, so the enum reflects the engine's current full capability.
 export const TTS_SUPERTONIC_LANGUAGES = [
-    "en", // English
-    "ko", // Korean
-    "ja", // Japanese
-    "ar", // Arabic
-    "bg", // Bulgarian
-    "cs", // Czech
-    "da", // Danish
-    "de", // German
-    "el", // Greek
-    "es", // Spanish
-    "et", // Estonian
-    "fi", // Finnish
-    "fr", // French
-    "hi", // Hindi
-    "hr", // Croatian
-    "hu", // Hungarian
-    "id", // Indonesian
-    "it", // Italian
-    "lt", // Lithuanian
-    "lv", // Latvian
-    "nl", // Dutch
-    "pl", // Polish
-    "pt", // Portuguese
-    "ro", // Romanian
-    "ru", // Russian
-    "sk", // Slovak
-    "sl", // Slovenian
-    "sv", // Swedish
-    "tr", // Turkish
-    "uk", // Ukrainian
-    "vi", // Vietnamese
+    'en', // English
+    'ko', // Korean
+    'ja', // Japanese
+    'ar', // Arabic
+    'bg', // Bulgarian
+    'cs', // Czech
+    'da', // Danish
+    'de', // German
+    'el', // Greek
+    'es', // Spanish
+    'et', // Estonian
+    'fi', // Finnish
+    'fr', // French
+    'hi', // Hindi
+    'hr', // Croatian
+    'hu', // Hungarian
+    'id', // Indonesian
+    'it', // Italian
+    'lt', // Lithuanian
+    'lv', // Latvian
+    'nl', // Dutch
+    'pl', // Polish
+    'pt', // Portuguese
+    'ro', // Romanian
+    'ru', // Russian
+    'sk', // Slovak
+    'sl', // Slovenian
+    'sv', // Swedish
+    'tr', // Turkish
+    'uk', // Ukrainian
+    'vi' // Vietnamese
 ];
 // Supertonic languages not already present in the Chatterbox set, used to keep
 // TTS_LANGUAGES a true union across engines without duplicates.
 const TTS_SUPERTONIC_ONLY_LANGUAGES = [
-    "ja", // Japanese
-    "bg", // Bulgarian
-    "cs", // Czech
-    "et", // Estonian
-    "hr", // Croatian
-    "hu", // Hungarian
-    "id", // Indonesian
-    "lt", // Lithuanian
-    "lv", // Latvian
-    "ro", // Romanian
-    "sk", // Slovak
-    "sl", // Slovenian
-    "uk", // Ukrainian
-    "vi", // Vietnamese
+    'bg', // Bulgarian
+    'cs', // Czech
+    'et', // Estonian
+    'hr', // Croatian
+    'hu', // Hungarian
+    'id', // Indonesian
+    'lt', // Lithuanian
+    'lv', // Latvian
+    'ro', // Romanian
+    'sk', // Slovak
+    'sl', // Slovenian
+    'uk', // Ukrainian
+    'vi' // Vietnamese
 ];
 // Union of all TTS-supported languages across engines. Kept for backwards
 // compatibility; prefer the engine-specific lists when validating a config.
 export const TTS_LANGUAGES = [
     ...TTS_CHATTERBOX_LANGUAGES,
-    ...TTS_SUPERTONIC_ONLY_LANGUAGES,
+    ...TTS_SUPERTONIC_ONLY_LANGUAGES
 ];
 const ttsChatterboxLanguageSchema = z.enum(TTS_CHATTERBOX_LANGUAGES);
 const ttsSupertonicLanguageSchema = z.enum(TTS_SUPERTONIC_LANGUAGES);
 const ttsIntegerSchema = z.number().int();
 const ttsNonNegativeIntegerSchema = ttsIntegerSchema.nonnegative();
 const ttsPositiveIntegerSchema = ttsIntegerSchema.positive();
+// Desired output sample rate in Hz. Matches the @qvac/tts-ggml addon's
+// accepted range; omit to keep the engine's native rate (or 48 kHz when the
+// LavaSR enhancer is active). Supertonic-only: the Chatterbox engine does not
+// yet resample its output, so the field is not exposed on that config.
+const ttsOutputSampleRateSchema = ttsIntegerSchema.min(8000).max(192000);
 export const ttsChatterboxRuntimeConfigSchema = z.object({
-    ttsEngine: z.literal("chatterbox"),
+    ttsEngine: z.literal('chatterbox'),
     language: ttsChatterboxLanguageSchema,
     voice: z.string().optional(),
     useGPU: z.boolean().optional(),
@@ -100,33 +105,66 @@ export const ttsChatterboxRuntimeConfigSchema = z.object({
     streamChunkTokens: ttsNonNegativeIntegerSchema.optional(),
     streamFirstChunkTokens: ttsNonNegativeIntegerSchema.optional(),
     cfmSteps: ttsNonNegativeIntegerSchema.optional(),
+    cfgRate: z.number().nonnegative().optional(),
     threads: ttsPositiveIntegerSchema.optional(),
     nGpuLayers: ttsIntegerSchema.optional(),
-    seed: ttsIntegerSchema.optional(),
+    seed: ttsIntegerSchema.optional()
 });
 export const ttsSupertonicRuntimeConfigSchema = z.object({
-    ttsEngine: z.literal("supertonic"),
+    ttsEngine: z.literal('supertonic'),
     language: ttsSupertonicLanguageSchema,
     voice: z.string().optional(),
     ttsSpeed: z.number().optional(),
     ttsNumInferenceSteps: z.number().optional(),
     useGPU: z.boolean().optional(),
+    outputSampleRate: ttsOutputSampleRateSchema.optional(),
+    vulkanCacheDir: z.string().min(1).optional()
 });
-export const ttsRuntimeConfigSchema = z.discriminatedUnion("ttsEngine", [
+export const ttsRuntimeConfigSchema = z.discriminatedUnion('ttsEngine', [
     ttsChatterboxRuntimeConfigSchema,
-    ttsSupertonicRuntimeConfigSchema,
+    ttsSupertonicRuntimeConfigSchema
 ]);
+// Optional LavaSR post-processing model sources, shared across engines. Supply
+// the enhancer GGUF to bandwidth-extend the output to 48 kHz, and/or the
+// denoiser GGUF (runs before the enhancer, rate-preserving). Resolved to
+// artifacts by the plugin's resolveConfig and forwarded to @qvac/tts-ggml.
+const ttsLavasrLoadFieldsShape = {
+    lavasrEnhancerModelSrc: modelSrcInputSchema.optional(),
+    lavasrDenoiserModelSrc: modelSrcInputSchema.optional()
+};
 export const ttsChatterboxLoadConfigSchema = ttsChatterboxRuntimeConfigSchema.extend({
     // Optional at schema time so legacy ONNX configs (no s3genModelSrc) reach
     // the plugin's resolveConfig and raise LegacyTtsModelDeprecatedError.
     s3genModelSrc: modelSrcInputSchema.optional(),
     referenceAudioSrc: modelSrcInputSchema.optional(),
+    mecabDictSrc: modelSrcInputSchema.optional(),
+    cangjieTsvSrc: modelSrcInputSchema.optional(),
+    ...ttsLavasrLoadFieldsShape
 });
-export const ttsSupertonicLoadConfigSchema = ttsSupertonicRuntimeConfigSchema;
-export const ttsLoadConfigSchema = z.discriminatedUnion("ttsEngine", [
-    ttsChatterboxLoadConfigSchema,
-    ttsSupertonicLoadConfigSchema,
-]);
+export const ttsSupertonicLoadConfigSchema = ttsSupertonicRuntimeConfigSchema.extend({
+    ...ttsLavasrLoadFieldsShape
+});
+function refineChatterboxTokenizerAssets(data, ctx) {
+    if (data.ttsEngine !== 'chatterbox')
+        return;
+    if (data.language === 'ja' && data.mecabDictSrc === undefined) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['mecabDictSrc'],
+            message: 'mecabDictSrc is required when Chatterbox language is "ja".'
+        });
+    }
+    if (data.language === 'zh' && data.cangjieTsvSrc === undefined) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['cangjieTsvSrc'],
+            message: 'cangjieTsvSrc is required when Chatterbox language is "zh".'
+        });
+    }
+}
+export const ttsLoadConfigSchema = z
+    .discriminatedUnion('ttsEngine', [ttsChatterboxLoadConfigSchema, ttsSupertonicLoadConfigSchema])
+    .superRefine(refineChatterboxTokenizerAssets);
 // === Legacy ONNX modelConfig fields (deprecated) ===
 //
 // Pre-@qvac/tts-ggml multi-file ONNX `modelConfig` fields are kept ONLY so
@@ -135,19 +173,19 @@ export const ttsLoadConfigSchema = z.discriminatedUnion("ttsEngine", [
 // rather than a generic Zod `Unrecognized key` error.
 export const LEGACY_TTS_ONNX_MODEL_CONFIG_FIELDS = [
     // ONNX runtime flag; GGML uses modelSrc (GGUF) + `language` instead.
-    "ttsSupertonicMultilingual",
-    "ttsTokenizerSrc",
-    "ttsSpeechEncoderSrc",
-    "ttsEmbedTokensSrc",
-    "ttsConditionalDecoderSrc",
-    "ttsLanguageModelSrc",
-    "ttsTextEncoderSrc",
-    "ttsDurationPredictorSrc",
-    "ttsVectorEstimatorSrc",
-    "ttsVocoderSrc",
-    "ttsUnicodeIndexerSrc",
-    "ttsTtsConfigSrc",
-    "ttsVoiceStyleSrc",
+    'ttsSupertonicMultilingual',
+    'ttsTokenizerSrc',
+    'ttsSpeechEncoderSrc',
+    'ttsEmbedTokensSrc',
+    'ttsConditionalDecoderSrc',
+    'ttsLanguageModelSrc',
+    'ttsTextEncoderSrc',
+    'ttsDurationPredictorSrc',
+    'ttsVectorEstimatorSrc',
+    'ttsVocoderSrc',
+    'ttsUnicodeIndexerSrc',
+    'ttsTtsConfigSrc',
+    'ttsVoiceStyleSrc'
 ];
 const legacyTtsOnnxFieldsShape = LEGACY_TTS_ONNX_MODEL_CONFIG_FIELDS.reduce((acc, name) => {
     acc[name] = z.unknown().optional();
@@ -157,53 +195,57 @@ const legacyTtsOnnxFieldsShape = LEGACY_TTS_ONNX_MODEL_CONFIG_FIELDS.reduce((acc
 // `loadConfigSchema`. Permits deprecated ONNX field names so
 // `resolveConfig` can raise LegacyTtsModelDeprecatedError instead of a
 // generic Zod error; other unknown keys are still rejected by `.strict()`.
-export const ttsConfigSchema = z.discriminatedUnion("ttsEngine", [
+export const ttsConfigSchema = z
+    .discriminatedUnion('ttsEngine', [
     ttsChatterboxLoadConfigSchema.extend(legacyTtsOnnxFieldsShape).strict(),
-    ttsSupertonicLoadConfigSchema.extend(legacyTtsOnnxFieldsShape).strict(),
-]);
+    ttsSupertonicLoadConfigSchema.extend(legacyTtsOnnxFieldsShape).strict()
+])
+    .superRefine(refineChatterboxTokenizerAssets);
 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"),
+    inputType: z.string().default('text'),
+    text: z.string().trim().min(1, 'text must not be empty or whitespace-only'),
     stream: z.boolean().default(true),
     sentenceStream: z.boolean().default(false),
     sentenceStreamLocale: z.string().optional(),
-    sentenceStreamMaxChunkScalars: z.number().positive().optional(),
+    sentenceStreamMaxChunkScalars: z.number().positive().optional()
 });
 export const ttsRequestSchema = ttsClientParamsSchema.extend({
-    type: z.literal("textToSpeech"),
+    type: z.literal('textToSpeech')
 });
 export const ttsStatsSchema = z.object({
     audioDuration: z.number().optional(),
     totalSamples: z.number().optional(),
+    enhancerBackendDevice: z.number().optional(),
+    enhancerBackendId: z.number().optional()
 });
 export const ttsResponseSchema = z.object({
-    type: z.literal("textToSpeech"),
+    type: z.literal('textToSpeech'),
     buffer: z.array(z.number()),
     done: z.boolean().default(false),
     stats: ttsStatsSchema.optional(),
     chunkIndex: z.number().int().nonnegative().optional(),
-    sentenceChunk: z.string().optional(),
+    sentenceChunk: z.string().optional()
 });
 // Internal: kept un-exported to present a single request-schema surface to
 // consumers. The inferred `TextToSpeechStreamClientParams` type below uses
 // this shape via `typeof`, no runtime export needed.
 const textToSpeechStreamRequestBaseSchema = z.object({
     modelId: z.string(),
-    inputType: z.string().default("text"),
+    inputType: z.string().default('text'),
     accumulateSentences: z.boolean().optional(),
-    sentenceDelimiterPreset: z.enum(["latin", "cjk", "multilingual"]).optional(),
+    sentenceDelimiterPreset: z.enum(['latin', 'cjk', 'multilingual']).optional(),
     maxBufferScalars: z.number().positive().optional(),
-    flushAfterMs: z.number().positive().optional(),
+    flushAfterMs: z.number().positive().optional()
 });
 export const textToSpeechStreamRequestSchema = textToSpeechStreamRequestBaseSchema.extend({
-    type: z.literal("textToSpeechStream"),
+    type: z.literal('textToSpeechStream')
 });
 export const textToSpeechStreamResponseSchema = z.object({
-    type: z.literal("textToSpeechStream"),
+    type: z.literal('textToSpeechStream'),
     buffer: z.array(z.number()),
     done: z.boolean().default(false),
     stats: ttsStatsSchema.optional(),
     chunkIndex: z.number().int().nonnegative().optional(),
-    sentenceChunk: z.string().optional(),
+    sentenceChunk: z.string().optional()
 });

package/dist/schemas/tools.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 /**
  * `static` (default) — tools are prepended once after the system message and
  * shared across the chat session.
@@ -31,7 +31,7 @@ export declare const toolSchema: z.ZodObject<{
                 integer: "integer";
             }>;
             description: z.ZodOptional<z.ZodString>;
-            enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            enum: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
         }, z.core.$strip>>;
         required: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;

package/dist/schemas/tools.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 /**
  * `static` (default) — tools are prepended once after the system message and
  * shared across the chat session.
@@ -11,48 +11,42 @@ import { z } from "zod";
  * mapping can change without breaking the public API.
  */
 export const TOOLS_MODE = {
-    static: "static",
-    dynamic: "dynamic",
+    static: 'static',
+    dynamic: 'dynamic'
 };
+const jsonSchemaEnumValueSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]);
 export const toolSchema = z.object({
-    type: z.literal("function"),
+    type: z.literal('function'),
     name: z.string(),
     description: z.string(),
     parameters: z.object({
-        type: z.literal("object"),
+        type: z.literal('object'),
         properties: z.record(z.string(), z.object({
-            type: z.enum([
-                "string",
-                "number",
-                "integer",
-                "boolean",
-                "object",
-                "array",
-            ]),
+            type: z.enum(['string', 'number', 'integer', 'boolean', 'object', 'array']),
             description: z.string().optional(),
-            enum: z.array(z.string()).optional(),
+            enum: z.array(jsonSchemaEnumValueSchema).optional()
         })),
-        required: z.array(z.string()).optional(),
-    }),
+        required: z.array(z.string()).optional()
+    })
 });
 export const toolCallSchema = z.object({
     id: z.string(),
     name: z.string(),
     arguments: z.record(z.string(), z.unknown()),
-    raw: z.string().optional(),
+    raw: z.string().optional()
 });
 export const toolCallErrorSchema = z.object({
-    code: z.enum(["PARSE_ERROR", "VALIDATION_ERROR", "UNKNOWN_TOOL"]),
+    code: z.enum(['PARSE_ERROR', 'VALIDATION_ERROR', 'UNKNOWN_TOOL']),
     message: z.string(),
-    raw: z.string().optional(),
+    raw: z.string().optional()
 });
 export const toolCallEventSchema = z.union([
     z.object({
-        type: z.literal("toolCall"),
-        call: toolCallSchema,
+        type: z.literal('toolCall'),
+        call: toolCallSchema
     }),
     z.object({
-        type: z.literal("toolCallError"),
-        error: toolCallErrorSchema,
-    }),
+        type: z.literal('toolCallError'),
+        error: toolCallErrorSchema
+    })
 ]);

package/dist/schemas/transcription-config.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 export declare const audioFormatSchema: z.ZodEnum<{
     f32le: "f32le";
     s16le: "s16le";

package/dist/schemas/transcription-config.js

@@ -1,7 +1,7 @@
-import { z } from "zod";
-import { modelSrcInputSchema } from "./model-src-utils.js";
+import { z } from 'zod';
+import { modelSrcInputSchema } from './model-src-utils.js';
 // === Shared ===
-export const audioFormatSchema = z.enum(["f32le", "s16le"]);
+export const audioFormatSchema = z.enum(['f32le', 's16le']);
 // === Whisper (whisper.cpp) engine config ===
 const vadParamsSchema = z
     .object({
@@ -10,7 +10,7 @@ const vadParamsSchema = z
     min_silence_duration_ms: z.number().optional(),
     max_speech_duration_s: z.number().optional(),
     speech_pad_ms: z.number().optional(),
-    samples_overlap: z.number().optional(),
+    samples_overlap: z.number().optional()
 })
     .optional();
 const contextParamsSchema = z
@@ -18,16 +18,16 @@ const contextParamsSchema = z
     model: z.string().optional(),
     use_gpu: z.boolean().optional(),
     flash_attn: z.boolean().optional(),
-    gpu_device: z.number().optional(),
+    gpu_device: z.number().optional()
 })
     .optional();
 const miscConfigSchema = z
     .object({
-    caption_enabled: z.boolean().optional(),
+    caption_enabled: z.boolean().optional()
 })
     .optional();
 export const whisperConfigSchema = z.object({
-    strategy: z.enum(["greedy", "beam_search"]).optional(),
+    strategy: z.enum(['greedy', 'beam_search']).optional(),
     n_threads: z.number().int().optional(),
     n_max_text_ctx: z.number().int().optional(),
     offset_ms: z.number().int().optional(),
@@ -66,7 +66,7 @@ export const whisperConfigSchema = z.object({
     audio_format: audioFormatSchema.optional(),
     contextParams: contextParamsSchema,
     miscConfig: miscConfigSchema,
-    vadModelSrc: modelSrcInputSchema.optional(),
+    vadModelSrc: modelSrcInputSchema.optional()
 });
 // === Parakeet (NVIDIA NeMo GGML) engine config ===
 //
@@ -115,7 +115,7 @@ export const parakeetRuntimeConfigSchema = z.object({
     streamingChunkRightContextMs: z.number().int().nonnegative().optional(),
     streamingSpkCacheUpdatePeriod: z.number().int().positive().optional(),
     backendsDir: z.string().optional(),
-    openclCacheDir: z.string().optional(),
+    openclCacheDir: z.string().optional()
 });
 // Parakeet's load-time config currently has no fields beyond the
 // runtime knobs (single GGUF model is supplied via the top-level
@@ -132,15 +132,15 @@ export const parakeetConfigSchema = parakeetRuntimeConfigSchema;
 // message) raised from the parakeet plugin's `resolveConfig`, rather
 // than a generic Zod `Unrecognized key` error.
 export const LEGACY_PARAKEET_ONNX_MODEL_CONFIG_FIELDS = [
-    "parakeetEncoderSrc",
-    "parakeetDecoderSrc",
-    "parakeetVocabSrc",
-    "parakeetPreprocessorSrc",
-    "parakeetCtcModelSrc",
-    "parakeetTokenizerSrc",
-    "parakeetSortformerSrc",
-    "parakeetModelSrc",
-    "modelType",
+    'parakeetEncoderSrc',
+    'parakeetDecoderSrc',
+    'parakeetVocabSrc',
+    'parakeetPreprocessorSrc',
+    'parakeetCtcModelSrc',
+    'parakeetTokenizerSrc',
+    'parakeetSortformerSrc',
+    'parakeetModelSrc',
+    'modelType'
 ];
 const legacyParakeetOnnxFieldsShape = LEGACY_PARAKEET_ONNX_MODEL_CONFIG_FIELDS.reduce((acc, name) => {
     acc[name] = z.unknown().optional();

package/dist/schemas/transcription.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 export declare const audioInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"base64">;
     value: z.ZodString;
@@ -241,15 +241,15 @@ export type WhisperEndOfTurnEvent = z.infer<typeof whisperEndOfTurnEventSchema>;
 export type ParakeetEndOfTurnEvent = z.infer<typeof parakeetEndOfTurnEventSchema>;
 export type EndOfTurnEvent = z.infer<typeof endOfTurnEventSchema>;
 export type TranscribeStreamEvent = {
-    type: "text";
+    type: 'text';
     text: string;
 } | {
-    type: "segment";
+    type: 'segment';
     segment: TranscribeSegment;
 } | ({
-    type: "vad";
+    type: 'vad';
 } & VadStateEvent) | ({
-    type: "endOfTurn";
+    type: 'endOfTurn';
 } & EndOfTurnEvent);
 export interface TranscribeStreamConversationSession {
     write(audioChunk: Uint8Array): void;