expect(fetchMock).toHaveBeenCalledTimes(1);

});

it("drops malformed latency tier overrides before synthesis", async () => {

const provider = buildElevenLabsSpeechProvider();

const fetchMock = vi.fn(async (url: string) => {

expect(new URL(url).searchParams.has("optimize_streaming_latency")).toBe(false);

return new Response(new Uint8Array([1, 2, 3]), { status: 200 });

});

globalThis.fetch = fetchMock as unknown as typeof fetch;

await provider.synthesize?.({

text: "hello",

target: "audio",

cfg: {} as never,

providerConfig: {

apiKey: "xi-test",

},

providerOverrides: {

latencyTier: 2.5,

},

timeoutMs: 1_000,

});

expect(fetchMock).toHaveBeenCalledTimes(1);

});

});

: undefined;

}

function normalizeElevenLabsLatencyTier(value: unknown): number | undefined {

const latencyTier = asFiniteNumber(value);

return latencyTier !== undefined &&

Number.isSafeInteger(latencyTier) &&

latencyTier >= 0 &&

latencyTier <= 4

? latencyTier

: undefined;

}

function normalizeVoiceSettings(

rawVoiceSettings: Record<string, unknown> | undefined,

): Partial<ElevenLabsProviderConfig["voiceSettings"]> {

resolveTalkOverrides: ({ params }) => {

const normalize = trimToUndefined(params.normalize);

const language = normalizeLowercaseStringOrEmpty(trimToUndefined(params.language));

const latencyTier = asFiniteNumber(params.latencyTier);

const latencyTier = normalizeElevenLabsLatencyTier(params.latencyTier);

const voiceSettings = {

...(normalizeVoiceSetting(params.speed, 0.5, 2) == null

? {}

const outputFormat =

trimToUndefined(overrides.outputFormat) ??

(req.target === "voice-note" ? "opus_48000_64" : "mp3_44100_128");

const latencyTier = asFiniteNumber(overrides.latencyTier);

const latencyTier = normalizeElevenLabsLatencyTier(overrides.latencyTier);

const audioBuffer = await elevenLabsTTS({

text: req.text,

apiKey,

const outputFormat =

trimToUndefined(overrides.outputFormat) ??

(req.target === "voice-note" ? "opus_48000_64" : "mp3_44100_128");

const latencyTier = asFiniteNumber(overrides.latencyTier);

const latencyTier = normalizeElevenLabsLatencyTier(overrides.latencyTier);

const stream = await elevenLabsTTSStream({

text: req.text,

apiKey,

expect(body.latency_optimization_level).toBeUndefined();

});

it("rejects fractional latency optimization instead of truncating it", async () => {

const fetchMock = vi.fn(async () => new Response(Buffer.from("mp3")));

globalThis.fetch = fetchMock as unknown as typeof fetch;

await expect(

elevenLabsTTS({

...createDefaultTtsRequest(),

latencyTier: 3.9,

}),

).rejects.toThrow("latencyTier must be an integer");

expect(fetchMock).not.toHaveBeenCalled();

});

it("omits latency optimization for eleven_v3 because the API rejects it", async () => {

const fetchMock = vi.fn(async () => new Response(Buffer.from("mp3")));

globalThis.fetch = fetchMock as unknown as typeof fetch;

return undefined;

}

function normalizeElevenLabsLatencyTier(latencyTier: number | undefined): number | undefined {

if (latencyTier === undefined || !Number.isFinite(latencyTier)) {

return undefined;

}

if (!Number.isSafeInteger(latencyTier)) {

throw new Error("latencyTier must be an integer");

}

requireInRange(latencyTier, 0, 4, "latencyTier");

return latencyTier;

}

type ElevenLabsTtsRequestParams = {

text: string;

apiKey: string;

const normalizedNormalization = normalizeApplyTextNormalization(applyTextNormalization);

const normalizedSeed = normalizeSeed(seed);

const normalizedBaseUrl = normalizeElevenLabsBaseUrl(baseUrl);

const normalizedLatencyTier =

typeof latencyTier === "number" && Number.isFinite(latencyTier)

? Math.trunc(latencyTier)

: undefined;

if (normalizedLatencyTier !== undefined) {

requireInRange(normalizedLatencyTier, 0, 4, "latencyTier");

}

const normalizedLatencyTier = normalizeElevenLabsLatencyTier(latencyTier);

const url = new URL(

`${normalizedBaseUrl}/v1/text-to-speech/${voiceId}${params.stream ? "/stream" : ""}`,

);