@qvac/sdk 0.18.2 → 0.19.0

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

@@ -1,554 +0,0 @@
-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
-    '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
-];
-export const TTS_PARLER_EMOTIONS = [
-    'command',
-    'anger',
-    'narration',
-    'conversation',
-    'disgust',
-    'fear',
-    'happy',
-    'neutral',
-    'proper noun',
-    'news',
-    'sad',
-    'surprise'
-];
-// Canonical cross-engine pace vocabulary (@qvac/tts-ggml `PACES`, unified in
-// QVAC-23154). `moderate` is the neutral pace: on CosyVoice3 it disengages the
-// pace conditioning channel entirely (plain zero-shot synthesis).
-export const TTS_PACES = ['slow', 'moderate', 'fast'];
-// CosyVoice3 supports a subset of the cross-engine emotion vocabulary and the
-// full canonical pace vocabulary.
-export const TTS_COSYVOICE3_EMOTIONS = ['anger', 'happy', 'neutral', 'sad'];
-// CosyVoice3 structured-instruct control vocabulary (@qvac/tts-ggml
-// `CosyvoiceInstruct`). Exactly one control renders per synthesis, resolved by
-// precedence dialect > volume > style.
-export const TTS_COSYVOICE3_INSTRUCT_DIALECTS = [
-    'cantonese',
-    'northeastern',
-    'gansu',
-    'guizhou',
-    'henan',
-    'hubei',
-    'hunan',
-    'jiangxi',
-    'minnan',
-    'ningxia',
-    'shanxi',
-    'shaanxi',
-    'shandong',
-    'shanghai',
-    'sichuan',
-    'tianjin',
-    'yunnan'
-];
-export const TTS_COSYVOICE3_INSTRUCT_VOLUMES = ['loud', 'soft'];
-export const TTS_COSYVOICE3_INSTRUCT_STYLES = ['peppa', 'robot'];
-// 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 = [
-    '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
-];
-const ttsChatterboxLanguageSchema = z.enum(TTS_CHATTERBOX_LANGUAGES);
-const ttsSupertonicLanguageSchema = z.enum(TTS_SUPERTONIC_LANGUAGES);
-const ttsParlerEmotionSchema = z.enum(TTS_PARLER_EMOTIONS);
-const ttsCosyvoice3EmotionSchema = z.enum(TTS_COSYVOICE3_EMOTIONS);
-const ttsPaceSchema = z.enum(TTS_PACES);
-const ttsIntegerSchema = z.number().int();
-const ttsNonNegativeIntegerSchema = ttsIntegerSchema.nonnegative();
-const ttsPositiveIntegerSchema = ttsIntegerSchema.positive();
-const ttsInt32Schema = ttsIntegerSchema.min(-2147483648).max(2147483647);
-const ttsNonNegativeInt32Schema = ttsInt32Schema.nonnegative();
-const ttsPositiveInt32Schema = ttsInt32Schema.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);
-const ttsParlerDescriptionFieldsShape = {
-    description: z.string().min(1).optional(),
-    voiceDescription: z.string().min(1).optional(),
-    voice: z.string().min(1).optional(),
-    emotion: ttsParlerEmotionSchema.optional(),
-    pitch: z.string().min(1).optional(),
-    // Canonical cross-engine vocabulary since @qvac/tts-ggml 0.7 (QVAC-23154);
-    // free-form pace strings are rejected natively.
-    pace: ttsPaceSchema.optional(),
-    expressivity: z.string().min(1).optional(),
-    noise: z.string().min(1).optional(),
-    reverb: z.string().min(1).optional(),
-    quality: z.string().min(1).optional()
-};
-const ttsParlerTemplateFieldNames = [
-    'voice',
-    'emotion',
-    'pitch',
-    'pace',
-    'expressivity',
-    'noise',
-    'reverb',
-    'quality'
-];
-function refineParlerDescriptionFields(config, ctx) {
-    if (config.description !== undefined && config.voiceDescription !== undefined) {
-        ctx.addIssue({
-            code: 'custom',
-            path: ['voiceDescription'],
-            message: 'description and voiceDescription are mutually exclusive.'
-        });
-    }
-    if (config.description === undefined && config.voiceDescription === undefined)
-        return;
-    const conflictingField = ttsParlerTemplateFieldNames.find((field) => config[field] !== undefined);
-    if (conflictingField) {
-        ctx.addIssue({
-            code: 'custom',
-            path: [conflictingField],
-            message: 'description and voiceDescription are mutually exclusive with Parler voice-template fields.'
-        });
-    }
-}
-function refineParlerRuntimeConfig(config, ctx) {
-    refineParlerDescriptionFields(config, ctx);
-    const nativeStreamingEnabled = (config.streamChunkTokens ?? 0) > 0;
-    if (nativeStreamingEnabled &&
-        config.outputSampleRate !== undefined &&
-        config.outputSampleRate !== 44100) {
-        ctx.addIssue({
-            code: 'custom',
-            path: ['outputSampleRate'],
-            message: 'Parler native streaming emits at 44100 Hz; omit outputSampleRate, use 44100, or disable native streaming.'
-        });
-    }
-}
-export const ttsChatterboxRuntimeConfigSchema = z.object({
-    ttsEngine: z.literal('chatterbox'),
-    language: ttsChatterboxLanguageSchema,
-    voice: z.string().optional(),
-    useGPU: z.boolean().optional(),
-    // Chatterbox-only native streaming controls.
-    streamChunkTokens: ttsNonNegativeIntegerSchema.optional(),
-    streamFirstChunkTokens: ttsNonNegativeIntegerSchema.optional(),
-    cfmSteps: ttsNonNegativeIntegerSchema.optional(),
-    cfgRate: z.number().nonnegative().optional(),
-    threads: ttsPositiveIntegerSchema.optional(),
-    nGpuLayers: ttsIntegerSchema.optional(),
-    seed: ttsIntegerSchema.optional()
-});
-export const ttsSupertonicRuntimeConfigSchema = z.object({
-    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 ttsParlerRuntimeConfigSchema = z
-    .object({
-    ttsEngine: z.literal('parler'),
-    ...ttsParlerDescriptionFieldsShape,
-    useGPU: z.boolean().optional(),
-    outputSampleRate: ttsOutputSampleRateSchema.optional(),
-    streamChunkTokens: ttsNonNegativeInt32Schema.optional(),
-    streamFirstChunkTokens: ttsNonNegativeInt32Schema.optional(),
-    threads: ttsPositiveInt32Schema.optional(),
-    nGpuLayers: ttsInt32Schema.optional(),
-    seed: ttsInt32Schema.optional(),
-    temperature: z.number().nonnegative().optional(),
-    topK: ttsNonNegativeInt32Schema.optional(),
-    topP: z.number().positive().max(1).optional(),
-    maxFrames: z.union([z.literal(0), ttsInt32Schema.min(10)]).optional(),
-    minNewTokens: ttsInt32Schema.min(-1).optional(),
-    normalizeNumbers: z.boolean().optional()
-})
-    .superRefine(refineParlerRuntimeConfig);
-// CosyVoice3 structured instruct: a raw string passes through to the engine as
-// the exact instruction text (advanced escape hatch); the object form renders
-// exactly one trained control by precedence dialect > volume > style.
-// The string branch trims first: the addon trims too, so a whitespace-only
-// instruction would otherwise silently degrade to zero-shot synthesis.
-const ttsCosyvoice3InstructSchema = z.union([
-    z.string().trim().min(1),
-    z
-        .object({
-        dialect: z.enum(TTS_COSYVOICE3_INSTRUCT_DIALECTS).optional(),
-        volume: z.enum(TTS_COSYVOICE3_INSTRUCT_VOLUMES).optional(),
-        style: z.enum(TTS_COSYVOICE3_INSTRUCT_STYLES).optional()
-    })
-        .strict()
-        .refine((value) => value.dialect !== undefined || value.volume !== undefined || value.style !== undefined, { message: 'instruct requires at least one of dialect, volume, or style.' })
-]);
-// CosyVoice3 is trained on one instruction per synthesis: at most one of
-// `emotion`, a non-moderate `pace`, or `instruct` may be engaged at once
-// (`pace: 'moderate'` disengages the pace channel).
-function refineCosyvoice3ConditioningControls(config, ctx) {
-    const engaged = [];
-    if (config.emotion !== undefined)
-        engaged.push('emotion');
-    if (config.pace !== undefined && config.pace !== 'moderate')
-        engaged.push('pace');
-    if (config.instruct !== undefined)
-        engaged.push('instruct');
-    if (engaged.length > 1) {
-        ctx.addIssue({
-            code: 'custom',
-            path: [engaged[1]],
-            message: `CosyVoice3 accepts one conditioning control per synthesis; got ${engaged.join(', ')}. ` +
-                'Set exactly one (pace "moderate" disengages the pace channel).'
-        });
-    }
-}
-function refineCosyvoice3NativeStreamingRate(config, ctx) {
-    const nativeStreamingEnabled = (config.streamChunkTokens ?? 0) > 0;
-    if (nativeStreamingEnabled &&
-        config.outputSampleRate !== undefined &&
-        config.outputSampleRate !== 24000) {
-        ctx.addIssue({
-            code: 'custom',
-            path: ['outputSampleRate'],
-            message: 'CosyVoice3 native streaming emits at 24000 Hz; omit outputSampleRate, use 24000, ' +
-                'enable the LavaSR enhancer (which resamples seam-free), or disable native streaming.'
-        });
-    }
-}
-function refineCosyvoice3RuntimeConfig(config, ctx) {
-    refineCosyvoice3ConditioningControls(config, ctx);
-    refineCosyvoice3NativeStreamingRate(config, ctx);
-}
-const ttsCosyvoice3RuntimeConfigShape = {
-    ttsEngine: z.literal('cosyvoice3'),
-    emotion: ttsCosyvoice3EmotionSchema.optional(),
-    pace: ttsPaceSchema.optional(),
-    instruct: ttsCosyvoice3InstructSchema.optional(),
-    useGPU: z.boolean().optional(),
-    outputSampleRate: ttsOutputSampleRateSchema.optional(),
-    streamChunkTokens: ttsNonNegativeInt32Schema.optional(),
-    streamFirstChunkTokens: ttsNonNegativeInt32Schema.optional(),
-    threads: ttsPositiveInt32Schema.optional(),
-    nGpuLayers: ttsInt32Schema.optional(),
-    seed: ttsInt32Schema.optional()
-};
-export const ttsCosyvoice3RuntimeConfigSchema = z
-    .object(ttsCosyvoice3RuntimeConfigShape)
-    .superRefine(refineCosyvoice3RuntimeConfig);
-const ttsAudio8RuntimeConfigShape = {
-    ttsEngine: z.literal('audio8'),
-    // Transcript of the load-time reference recording (zero-shot voice cloning).
-    // Paired with `referenceAudioSrc` on the load config; kept on the runtime
-    // config because it survives artifact resolution as plain data.
-    // Trimmed for the same reason as the CosyVoice3 instruct string: a
-    // whitespace-only transcript would reach the engine as a non-empty value.
-    referenceText: z.string().trim().min(1).optional(),
-    greedy: z.boolean().optional(),
-    temperature: z.number().nonnegative().optional(),
-    topK: ttsNonNegativeInt32Schema.optional(),
-    topP: z.number().positive().max(1).optional(),
-    // Codec frames on Audio8's ~46 ms grid (~21.5 frames/s); 0 = engine default.
-    maxFrames: ttsNonNegativeInt32Schema.optional(),
-    useGPU: z.boolean().optional(),
-    outputSampleRate: ttsOutputSampleRateSchema.optional(),
-    threads: ttsPositiveInt32Schema.optional(),
-    nGpuLayers: ttsInt32Schema.optional(),
-    seed: ttsInt32Schema.optional()
-};
-export const ttsAudio8RuntimeConfigSchema = z.object(ttsAudio8RuntimeConfigShape);
-export const ttsRuntimeConfigSchema = z.discriminatedUnion('ttsEngine', [
-    ttsChatterboxRuntimeConfigSchema,
-    ttsSupertonicRuntimeConfigSchema,
-    ttsParlerRuntimeConfigSchema,
-    ttsCosyvoice3RuntimeConfigSchema,
-    ttsAudio8RuntimeConfigSchema
-]);
-// 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.extend({
-    ...ttsLavasrLoadFieldsShape
-});
-export const ttsParlerLoadConfigSchema = ttsParlerRuntimeConfigSchema;
-function refineCosyvoice3LoadConfig(config, ctx) {
-    refineCosyvoice3ConditioningControls(config, ctx);
-    // With the LavaSR enhancer active the addon resamples seam-free, so the
-    // 24 kHz native-streaming restriction only applies without it.
-    if (config.lavasrEnhancerModelSrc === undefined) {
-        refineCosyvoice3NativeStreamingRate(config, ctx);
-    }
-    if (config.lavasrDenoiserModelSrc !== undefined && (config.streamChunkTokens ?? 0) > 0) {
-        ctx.addIssue({
-            code: 'custom',
-            path: ['lavasrDenoiserModelSrc'],
-            message: 'The LavaSR denoiser is batch-only; disable native streaming (streamChunkTokens) to use it.'
-        });
-    }
-}
-// CosyVoice3 loads from a model *directory* (LLM/flow/HiFT GGUFs plus
-// voice.gguf, vocab.json and merges.txt). The primary `modelSrc` is the LLM
-// GGUF, whose registry companion set co-locates the remaining files, so the
-// load config only adds the optional LavaSR post-processing sources.
-export const ttsCosyvoice3LoadConfigSchema = z
-    .object({
-    ...ttsCosyvoice3RuntimeConfigShape,
-    ...ttsLavasrLoadFieldsShape
-})
-    .superRefine(refineCosyvoice3LoadConfig);
-function refineAudio8LoadConfig(config, ctx) {
-    if (config.referenceAudioSrc !== undefined && config.referenceText === undefined) {
-        ctx.addIssue({
-            code: 'custom',
-            path: ['referenceText'],
-            message: 'referenceText (the transcript of the reference recording) is required with referenceAudioSrc.'
-        });
-    }
-    if (config.referenceText !== undefined && config.referenceAudioSrc === undefined) {
-        ctx.addIssue({
-            code: 'custom',
-            path: ['referenceAudioSrc'],
-            message: 'referenceAudioSrc is required when referenceText is set.'
-        });
-    }
-    if (config.referenceAudioSrc !== undefined && config.audio8CodecEncoderModelSrc === undefined) {
-        ctx.addIssue({
-            code: 'custom',
-            path: ['audio8CodecEncoderModelSrc'],
-            message: 'Voice cloning requires the Audio8 codec encoder GGUF (audio8CodecEncoderModelSrc).'
-        });
-    }
-}
-// Audio8 loads from explicit per-component GGUFs: the primary `modelSrc` is
-// the DualAR LM, the codec decoder is required, and the codec encoder is only
-// needed for zero-shot voice cloning (reference audio + transcript).
-export const ttsAudio8LoadConfigSchema = z
-    .object({
-    ...ttsAudio8RuntimeConfigShape,
-    audio8CodecDecoderModelSrc: modelSrcInputSchema,
-    audio8CodecEncoderModelSrc: modelSrcInputSchema.optional(),
-    referenceAudioSrc: modelSrcInputSchema.optional()
-})
-    .superRefine(refineAudio8LoadConfig);
-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,
-    ttsParlerLoadConfigSchema,
-    ttsCosyvoice3LoadConfigSchema,
-    ttsAudio8LoadConfigSchema
-])
-    .superRefine(refineChatterboxTokenizerAssets);
-// === Legacy ONNX modelConfig fields (deprecated) ===
-//
-// Pre-@qvac/tts-ggml multi-file ONNX `modelConfig` fields are kept ONLY so
-// callers migrating from earlier SDK versions hit a structured
-// `LegacyTtsModelDeprecatedError` from the TTS plugin's `resolveConfig`,
-// 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'
-];
-const legacyTtsOnnxFieldsShape = LEGACY_TTS_ONNX_MODEL_CONFIG_FIELDS.reduce((acc, name) => {
-    acc[name] = z.unknown().optional();
-    return acc;
-}, {});
-// Strict load schema used by `loadModel` and the tts-ggml plugin's
-// `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', [
-    ttsChatterboxLoadConfigSchema.extend(legacyTtsOnnxFieldsShape).strict(),
-    ttsSupertonicLoadConfigSchema.extend(legacyTtsOnnxFieldsShape).strict(),
-    ttsParlerLoadConfigSchema.strict(),
-    ttsCosyvoice3LoadConfigSchema.strict(),
-    ttsAudio8LoadConfigSchema.strict()
-])
-    .superRefine(refineChatterboxTokenizerAssets);
-const ttsClientParamsShape = {
-    modelId: z.string(),
-    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(),
-    ...ttsParlerDescriptionFieldsShape
-};
-// Requests carry only an opaque modelId, so client-side validation cannot know
-// which TTS engine is loaded. Description conflicts are intentionally rejected
-// as malformed request shapes before the server performs engine compatibility
-// validation in assertParlerJobOptionsSupported.
-export const ttsClientParamsSchema = z
-    .object(ttsClientParamsShape)
-    .superRefine(refineParlerDescriptionFields);
-export const ttsRequestSchema = z
-    .object({
-    ...ttsClientParamsShape,
-    type: z.literal('textToSpeech')
-})
-    .superRefine(refineParlerDescriptionFields);
-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'),
-    buffer: z.array(z.number()),
-    done: z.boolean().default(false),
-    stats: ttsStatsSchema.optional(),
-    chunkIndex: z.number().int().nonnegative().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 textToSpeechStreamRequestBaseShape = {
-    modelId: z.string(),
-    inputType: z.string().default('text'),
-    accumulateSentences: z.boolean().optional(),
-    sentenceDelimiterPreset: z.enum(['latin', 'cjk', 'multilingual']).optional(),
-    maxBufferScalars: z.number().positive().optional(),
-    flushAfterMs: z.number().positive().optional(),
-    ...ttsParlerDescriptionFieldsShape
-};
-export const textToSpeechStreamRequestSchema = z
-    .object({
-    ...textToSpeechStreamRequestBaseShape,
-    type: z.literal('textToSpeechStream')
-})
-    .superRefine(refineParlerDescriptionFields);
-export const textToSpeechStreamResponseSchema = z.object({
-    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()
-});

package/dist/schemas/tools.d.ts

@@ -1,65 +0,0 @@
-import { z } from 'zod';
-export declare const toolSchema: z.ZodObject<{
-    type: z.ZodLiteral<"function">;
-    name: z.ZodString;
-    description: z.ZodString;
-    parameters: z.ZodObject<{
-        type: z.ZodLiteral<"object">;
-        properties: z.ZodRecord<z.ZodString, z.ZodObject<{
-            type: z.ZodEnum<{
-                string: "string";
-                number: "number";
-                boolean: "boolean";
-                object: "object";
-                array: "array";
-                integer: "integer";
-            }>;
-            description: z.ZodOptional<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>;
-}, z.core.$strip>;
-export declare const toolCallSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    raw: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const toolCallErrorSchema: z.ZodObject<{
-    code: z.ZodEnum<{
-        PARSE_ERROR: "PARSE_ERROR";
-        VALIDATION_ERROR: "VALIDATION_ERROR";
-        UNKNOWN_TOOL: "UNKNOWN_TOOL";
-    }>;
-    message: z.ZodString;
-    raw: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const toolCallEventSchema: z.ZodUnion<readonly [z.ZodObject<{
-    type: z.ZodLiteral<"toolCall">;
-    call: z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodString;
-        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        raw: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"toolCallError">;
-    error: z.ZodObject<{
-        code: z.ZodEnum<{
-            PARSE_ERROR: "PARSE_ERROR";
-            VALIDATION_ERROR: "VALIDATION_ERROR";
-            UNKNOWN_TOOL: "UNKNOWN_TOOL";
-        }>;
-        message: z.ZodString;
-        raw: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip>]>;
-export type Tool = z.infer<typeof toolSchema>;
-export type ToolCall = z.infer<typeof toolCallSchema>;
-export type ToolCallError = z.infer<typeof toolCallErrorSchema>;
-export type ToolCallEvent = z.infer<typeof toolCallEventSchema>;
-export type ToolCallWithCall = ToolCall & {
-    invoke?: () => Promise<unknown>;
-};
-//# sourceMappingURL=tools.d.ts.map

package/dist/schemas/tools.js

@@ -1,37 +0,0 @@
-import { z } from 'zod';
-const jsonSchemaEnumValueSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]);
-export const toolSchema = z.object({
-    type: z.literal('function'),
-    name: z.string(),
-    description: z.string(),
-    parameters: z.object({
-        type: z.literal('object'),
-        properties: z.record(z.string(), z.object({
-            type: z.enum(['string', 'number', 'integer', 'boolean', 'object', 'array']),
-            description: z.string().optional(),
-            enum: z.array(jsonSchemaEnumValueSchema).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()
-});
-export const toolCallErrorSchema = z.object({
-    code: z.enum(['PARSE_ERROR', 'VALIDATION_ERROR', 'UNKNOWN_TOOL']),
-    message: z.string(),
-    raw: z.string().optional()
-});
-export const toolCallEventSchema = z.union([
-    z.object({
-        type: z.literal('toolCall'),
-        call: toolCallSchema
-    }),
-    z.object({
-        type: z.literal('toolCallError'),
-        error: toolCallErrorSchema
-    })
-]);