discoclaw 1.2.4 → 2.0.0

package/dist/voice/tts-deepgram.js

@@ -1,84 +0,0 @@
-const DEEPGRAM_SPEECH_URL = 'https://api.deepgram.com/v1/speak';
-const DEFAULT_MODEL = 'aura-2-asteria-en';
-const DEFAULT_SAMPLE_RATE = 24000;
-export const DEEPGRAM_MAX_CHARS = 2000;
-/**
- * Deepgram Aura TTS adapter.
- *
- * POSTs to `/v1/speak` requesting `linear16` encoding with `container=none`
- * (raw PCM s16le). Streams the response body and yields `AudioFrame` chunks.
- */
-export class DeepgramTtsProvider {
-    apiKey;
-    model;
-    sampleRate;
-    speed;
-    log;
-    fetchFn;
-    constructor(opts) {
-        if (opts.speed !== undefined && (opts.speed < 0.5 || opts.speed > 1.5)) {
-            throw new RangeError(`DeepgramTtsProvider: speed must be in range [0.5, 1.5], got ${opts.speed}`);
-        }
-        this.apiKey = opts.apiKey;
-        this.model = opts.model ?? DEFAULT_MODEL;
-        this.sampleRate = opts.sampleRate ?? DEFAULT_SAMPLE_RATE;
-        this.speed = opts.speed;
-        this.log = opts.log;
-        this.fetchFn = opts.fetchFn ?? globalThis.fetch;
-    }
-    async *synthesize(text) {
-        if (!text.trim())
-            return;
-        if (text.length > DEEPGRAM_MAX_CHARS) {
-            const originalLength = text.length;
-            const slice = text.slice(0, DEEPGRAM_MAX_CHARS);
-            const sentenceEnd = Math.max(slice.lastIndexOf('. '), slice.lastIndexOf('! '), slice.lastIndexOf('? '), slice.lastIndexOf('.\n'), slice.lastIndexOf('!\n'), slice.lastIndexOf('?\n'));
-            text = sentenceEnd > 0 ? slice.slice(0, sentenceEnd + 1) : (slice.lastIndexOf(' ') > 0 ? slice.slice(0, slice.lastIndexOf(' ')) : slice);
-            this.log.warn({ originalLength, truncatedLength: text.length }, 'Deepgram TTS: text truncated to prevent HTTP 413');
-        }
-        const params = new URLSearchParams({
-            model: this.model,
-            encoding: 'linear16',
-            sample_rate: String(this.sampleRate),
-            container: 'none',
-        });
-        if (this.speed !== undefined) {
-            params.set('speed', String(this.speed));
-        }
-        const url = `${DEEPGRAM_SPEECH_URL}?${params.toString()}`;
-        this.log.info({ model: this.model, textLength: text.length }, 'Deepgram TTS: sending synthesis request');
-        const response = await this.fetchFn(url, {
-            method: 'POST',
-            headers: {
-                Authorization: `Token ${this.apiKey}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({ text }),
-        });
-        if (!response.ok) {
-            const body = await response.text();
-            throw new Error(`Deepgram TTS API error: ${response.status} — ${body.slice(0, 200)}`);
-        }
-        if (!response.body) {
-            throw new Error('Deepgram TTS: response has no body stream');
-        }
-        const reader = response.body.getReader();
-        try {
-            for (;;) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                if (value && value.byteLength > 0) {
-                    yield {
-                        buffer: Buffer.from(value.buffer, value.byteOffset, value.byteLength),
-                        sampleRate: this.sampleRate,
-                        channels: 1,
-                    };
-                }
-            }
-        }
-        finally {
-            reader.releaseLock();
-        }
-    }
-}

package/dist/voice/tts-deepgram.test.js

@@ -1,220 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { DeepgramTtsProvider, DEEPGRAM_MAX_CHARS } from './tts-deepgram.js';
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function createLogger() {
-    return { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-}
-/** Build a mock ReadableStream that yields the given byte arrays, then closes. */
-function mockStream(chunks) {
-    let i = 0;
-    return new ReadableStream({
-        pull(controller) {
-            if (i < chunks.length) {
-                controller.enqueue(chunks[i]);
-                i++;
-            }
-            else {
-                controller.close();
-            }
-        },
-    });
-}
-function mockFetch(chunks = [new Uint8Array([1, 2, 3, 4])], ok = true, status = 200) {
-    return vi.fn().mockResolvedValue({
-        ok,
-        status,
-        body: ok ? mockStream(chunks) : null,
-        text: async () => 'API error body',
-    });
-}
-function makeProvider(overrides = {}) {
-    return new DeepgramTtsProvider({
-        apiKey: overrides.apiKey ?? 'test-key',
-        model: overrides.model,
-        sampleRate: overrides.sampleRate,
-        speed: overrides.speed,
-        log: overrides.log ?? createLogger(),
-        fetchFn: overrides.fetchFn ?? mockFetch(),
-    });
-}
-async function collectFrames(iter) {
-    const frames = [];
-    for await (const frame of iter) {
-        frames.push(frame);
-    }
-    return frames;
-}
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-beforeEach(() => {
-    vi.clearAllMocks();
-});
-describe('DeepgramTtsProvider', () => {
-    it('sends correct API request with default model and linear16 encoding', async () => {
-        const fetchFn = mockFetch([new Uint8Array([10, 20])]);
-        const provider = makeProvider({ fetchFn, apiKey: 'dg-my-key' });
-        await collectFrames(provider.synthesize('hello'));
-        expect(fetchFn).toHaveBeenCalledTimes(1);
-        const [url, init] = vi.mocked(fetchFn).mock.calls[0];
-        expect(url).toContain('https://api.deepgram.com/v1/speak');
-        expect(url).toContain('encoding=linear16');
-        expect(url).toContain('sample_rate=24000');
-        expect(url).toContain('container=none');
-        expect(url).toContain('model=aura-2-asteria-en');
-        expect(init.headers.Authorization).toBe('Token dg-my-key');
-        expect(init.headers['Content-Type']).toBe('application/json');
-        const body = JSON.parse(init.body);
-        expect(body.text).toBe('hello');
-    });
-    it('uses custom model and sampleRate', async () => {
-        const fetchFn = mockFetch([new Uint8Array([1])]);
-        const provider = makeProvider({
-            fetchFn,
-            model: 'aura-2-luna-en',
-            sampleRate: 48000,
-        });
-        const frames = await collectFrames(provider.synthesize('test'));
-        const [url] = vi.mocked(fetchFn).mock.calls[0];
-        expect(url).toContain('model=aura-2-luna-en');
-        expect(url).toContain('sample_rate=48000');
-        expect(frames[0].sampleRate).toBe(48000);
-    });
-    it('streams multiple audio frames with correct metadata', async () => {
-        const chunks = [
-            new Uint8Array([1, 2, 3]),
-            new Uint8Array([4, 5, 6]),
-            new Uint8Array([7, 8, 9]),
-        ];
-        const fetchFn = mockFetch(chunks);
-        const provider = makeProvider({ fetchFn });
-        const frames = await collectFrames(provider.synthesize('hello world'));
-        expect(frames).toHaveLength(3);
-        expect([...frames[0].buffer]).toEqual([1, 2, 3]);
-        expect([...frames[1].buffer]).toEqual([4, 5, 6]);
-        expect([...frames[2].buffer]).toEqual([7, 8, 9]);
-        for (const frame of frames) {
-            expect(frame.sampleRate).toBe(24000);
-            expect(frame.channels).toBe(1);
-        }
-    });
-    it('empty text yields no frames and does not call API', async () => {
-        const fetchFn = mockFetch();
-        const provider = makeProvider({ fetchFn });
-        const frames = await collectFrames(provider.synthesize(''));
-        expect(frames).toHaveLength(0);
-        const frames2 = await collectFrames(provider.synthesize('   '));
-        expect(frames2).toHaveLength(0);
-        expect(fetchFn).not.toHaveBeenCalled();
-    });
-    it('throws on non-OK HTTP response', async () => {
-        const fetchFn = mockFetch([], false, 429);
-        const provider = makeProvider({ fetchFn });
-        await expect(collectFrames(provider.synthesize('test'))).rejects.toThrow('Deepgram TTS API error: 429');
-    });
-    it('throws when response has no body stream', async () => {
-        const fetchFn = vi.fn().mockResolvedValue({
-            ok: true,
-            status: 200,
-            body: null,
-            text: async () => '',
-        });
-        const provider = makeProvider({ fetchFn });
-        await expect(collectFrames(provider.synthesize('test'))).rejects.toThrow('response has no body stream');
-    });
-    describe('text truncation', () => {
-        it('passes through text under the limit unchanged', async () => {
-            const fetchFn = mockFetch();
-            const provider = makeProvider({ fetchFn });
-            const shortText = 'a'.repeat(DEEPGRAM_MAX_CHARS - 1);
-            await collectFrames(provider.synthesize(shortText));
-            const [, init] = vi.mocked(fetchFn).mock.calls[0];
-            expect(JSON.parse(init.body).text).toBe(shortText);
-        });
-        it('passes through text exactly at the limit unchanged', async () => {
-            const fetchFn = mockFetch();
-            const provider = makeProvider({ fetchFn });
-            const exactText = 'a'.repeat(DEEPGRAM_MAX_CHARS);
-            await collectFrames(provider.synthesize(exactText));
-            const [, init] = vi.mocked(fetchFn).mock.calls[0];
-            expect(JSON.parse(init.body).text).toBe(exactText);
-        });
-        it('truncates text over the limit to at most DEEPGRAM_MAX_CHARS chars', async () => {
-            const fetchFn = mockFetch();
-            const provider = makeProvider({ fetchFn });
-            const longText = 'a'.repeat(DEEPGRAM_MAX_CHARS + 500);
-            await collectFrames(provider.synthesize(longText));
-            const [, init] = vi.mocked(fetchFn).mock.calls[0];
-            const sentText = JSON.parse(init.body).text;
-            expect(sentText.length).toBeLessThanOrEqual(DEEPGRAM_MAX_CHARS);
-        });
-        it('cuts at the last sentence boundary when truncating', async () => {
-            const fetchFn = mockFetch();
-            const log = createLogger();
-            const provider = makeProvider({ fetchFn, log });
-            // Build text with a sentence boundary well before the limit
-            const prefix = 'Hello world. ';
-            const filler = 'x'.repeat(DEEPGRAM_MAX_CHARS - prefix.length + 100);
-            const longText = prefix + filler;
-            await collectFrames(provider.synthesize(longText));
-            const [, init] = vi.mocked(fetchFn).mock.calls[0];
-            const sentText = JSON.parse(init.body).text;
-            expect(sentText).toBe('Hello world.');
-            expect(sentText.length).toBeLessThanOrEqual(DEEPGRAM_MAX_CHARS);
-        });
-        it('logs a warning with original and truncated lengths when truncating', async () => {
-            const fetchFn = mockFetch();
-            const log = createLogger();
-            const provider = makeProvider({ fetchFn, log });
-            const longText = 'a'.repeat(DEEPGRAM_MAX_CHARS + 100);
-            await collectFrames(provider.synthesize(longText));
-            expect(log.warn).toHaveBeenCalledTimes(1);
-            const [meta, msg] = vi.mocked(log.warn).mock.calls[0];
-            expect(meta.originalLength).toBe(longText.length);
-            expect(meta.truncatedLength).toBeLessThanOrEqual(DEEPGRAM_MAX_CHARS);
-            expect(msg).toContain('truncated');
-        });
-        it('does not log a warning for text within the limit', async () => {
-            const fetchFn = mockFetch();
-            const log = createLogger();
-            const provider = makeProvider({ fetchFn, log });
-            await collectFrames(provider.synthesize('short text'));
-            expect(log.warn).not.toHaveBeenCalled();
-        });
-    });
-    describe('speed parameter', () => {
-        it('includes speed in the URL when set', async () => {
-            const fetchFn = mockFetch([new Uint8Array([1])]);
-            const provider = makeProvider({ fetchFn, speed: 1.2 });
-            await collectFrames(provider.synthesize('hello'));
-            const [url] = vi.mocked(fetchFn).mock.calls[0];
-            expect(url).toContain('speed=1.2');
-        });
-        it('omits speed from the URL when not set', async () => {
-            const fetchFn = mockFetch([new Uint8Array([1])]);
-            const provider = makeProvider({ fetchFn });
-            await collectFrames(provider.synthesize('hello'));
-            const [url] = vi.mocked(fetchFn).mock.calls[0];
-            expect(url).not.toContain('speed=');
-        });
-        it('throws RangeError when speed is below 0.5', () => {
-            expect(() => makeProvider({ speed: 0.4 })).toThrow(RangeError);
-        });
-        it('throws RangeError when speed is above 1.5', () => {
-            expect(() => makeProvider({ speed: 1.6 })).toThrow(RangeError);
-        });
-    });
-    it('single large chunk yields one frame', async () => {
-        const big = new Uint8Array(16384);
-        big.fill(42);
-        const fetchFn = mockFetch([big]);
-        const provider = makeProvider({ fetchFn });
-        const frames = await collectFrames(provider.synthesize('long text'));
-        expect(frames).toHaveLength(1);
-        expect(frames[0].buffer.length).toBe(16384);
-        expect(frames[0].sampleRate).toBe(24000);
-        expect(frames[0].channels).toBe(1);
-    });
-});

package/dist/voice/tts-factory.js

@@ -1,52 +0,0 @@
-import { CartesiaTtsProvider } from './tts-cartesia.js';
-import { DeepgramTtsProvider } from './tts-deepgram.js';
-import { OpenaiTtsProvider } from './tts-openai.js';
-/**
- * Create a TTS provider based on the voice config.
- *
- * Maintainers: start with `docs/official-docs.md` before changing provider
- * wiring, model defaults, endpoint assumptions, or request parameters here.
- *
- * Currently supported: `cartesia` (Sonic-3 streaming via WebSocket, 24 kHz PCM),
- * `deepgram` (Aura streaming via REST, 24 kHz PCM),
- * `openai` (TTS API via REST, 24 kHz PCM).
- * Planned: `kokoro` (local Kokoro model, Phase 3b).
- *
- * Requires `DISCOCLAW_VOICE_ENABLED=1` and a provider-specific API key
- * (e.g. `CARTESIA_API_KEY`, `DEEPGRAM_API_KEY`, `OPENAI_API_KEY`). See docs/voice.md for setup.
- */
-export function createTtsProvider(config, log) {
-    switch (config.ttsProvider) {
-        case 'cartesia': {
-            if (!config.cartesiaApiKey) {
-                throw new Error('cartesiaApiKey is required when ttsProvider is "cartesia"');
-            }
-            return new CartesiaTtsProvider({
-                apiKey: config.cartesiaApiKey,
-                log,
-            });
-        }
-        case 'deepgram': {
-            if (!config.deepgramApiKey) {
-                throw new Error('deepgramApiKey is required when ttsProvider is "deepgram"');
-            }
-            return new DeepgramTtsProvider({
-                apiKey: config.deepgramApiKey,
-                model: config.deepgramTtsVoice,
-                speed: config.deepgramTtsSpeed,
-                log,
-            });
-        }
-        case 'openai': {
-            if (!config.openaiApiKey) {
-                throw new Error('openaiApiKey is required when ttsProvider is "openai"');
-            }
-            return new OpenaiTtsProvider({
-                apiKey: config.openaiApiKey,
-                log,
-            });
-        }
-        case 'kokoro':
-            throw new Error('Kokoro TTS adapter is not yet implemented (Phase 3b)');
-    }
-}

package/dist/voice/tts-factory.test.js

@@ -1,53 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { createTtsProvider } from './tts-factory.js';
-import { CartesiaTtsProvider } from './tts-cartesia.js';
-import { DeepgramTtsProvider } from './tts-deepgram.js';
-import { OpenaiTtsProvider } from './tts-openai.js';
-// Stub globalThis.WebSocket so CartesiaTtsProvider constructor doesn't throw
-class StubWebSocket {
-    onopen = null;
-    constructor() {
-        queueMicrotask(() => this.onopen?.({ type: 'open' }));
-    }
-    send() { }
-    close() { }
-}
-globalThis.WebSocket = StubWebSocket;
-function createLogger() {
-    return { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-}
-function baseConfig(overrides = {}) {
-    return {
-        enabled: true,
-        sttProvider: 'deepgram',
-        ttsProvider: 'cartesia',
-        cartesiaApiKey: 'test-key',
-        ...overrides,
-    };
-}
-describe('createTtsProvider', () => {
-    it('returns a CartesiaTtsProvider for cartesia config', () => {
-        const provider = createTtsProvider(baseConfig(), createLogger());
-        expect(provider).toBeInstanceOf(CartesiaTtsProvider);
-    });
-    it('throws when cartesiaApiKey is missing for cartesia provider', () => {
-        expect(() => createTtsProvider(baseConfig({ cartesiaApiKey: undefined }), createLogger())).toThrow('cartesiaApiKey is required');
-    });
-    it('returns a DeepgramTtsProvider for deepgram config', () => {
-        const provider = createTtsProvider(baseConfig({ ttsProvider: 'deepgram', deepgramApiKey: 'dg-test' }), createLogger());
-        expect(provider).toBeInstanceOf(DeepgramTtsProvider);
-    });
-    it('throws when deepgramApiKey is missing for deepgram provider', () => {
-        expect(() => createTtsProvider(baseConfig({ ttsProvider: 'deepgram' }), createLogger())).toThrow('deepgramApiKey is required');
-    });
-    it('returns an OpenaiTtsProvider for openai config', () => {
-        const provider = createTtsProvider(baseConfig({ ttsProvider: 'openai', openaiApiKey: 'sk-test' }), createLogger());
-        expect(provider).toBeInstanceOf(OpenaiTtsProvider);
-    });
-    it('throws when openaiApiKey is missing for openai provider', () => {
-        expect(() => createTtsProvider(baseConfig({ ttsProvider: 'openai' }), createLogger())).toThrow('openaiApiKey is required');
-    });
-    it('throws not-implemented for kokoro provider', () => {
-        expect(() => createTtsProvider(baseConfig({ ttsProvider: 'kokoro' }), createLogger())).toThrow('not yet implemented');
-    });
-});

package/dist/voice/tts-openai.js

@@ -1,70 +0,0 @@
-const OPENAI_SPEECH_URL = 'https://api.openai.com/v1/audio/speech';
-const DEFAULT_MODEL = 'tts-1';
-const DEFAULT_VOICE = 'alloy';
-const DEFAULT_SAMPLE_RATE = 24000;
-/**
- * OpenAI TTS adapter.
- *
- * POSTs to `/v1/audio/speech` requesting `pcm` format (raw 24 kHz 16-bit mono).
- * Streams the response body and yields `AudioFrame` chunks.
- * Keep the request body aligned with the official OpenAI audio speech docs.
- */
-export class OpenaiTtsProvider {
-    apiKey;
-    model;
-    voice;
-    sampleRate;
-    log;
-    fetchFn;
-    constructor(opts) {
-        this.apiKey = opts.apiKey;
-        this.model = opts.model ?? DEFAULT_MODEL;
-        this.voice = opts.voice ?? DEFAULT_VOICE;
-        this.sampleRate = opts.sampleRate ?? DEFAULT_SAMPLE_RATE;
-        this.log = opts.log;
-        this.fetchFn = opts.fetchFn ?? globalThis.fetch;
-    }
-    async *synthesize(text) {
-        if (!text.trim())
-            return;
-        this.log.info({ model: this.model, textLength: text.length }, 'OpenAI TTS: sending synthesis request');
-        const response = await this.fetchFn(OPENAI_SPEECH_URL, {
-            method: 'POST',
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                model: this.model,
-                input: text,
-                voice: this.voice,
-                response_format: 'pcm',
-            }),
-        });
-        if (!response.ok) {
-            const body = await response.text();
-            throw new Error(`OpenAI TTS API error: ${response.status} — ${body.slice(0, 200)}`);
-        }
-        if (!response.body) {
-            throw new Error('OpenAI TTS: response has no body stream');
-        }
-        const reader = response.body.getReader();
-        try {
-            for (;;) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                if (value && value.byteLength > 0) {
-                    yield {
-                        buffer: Buffer.from(value.buffer, value.byteOffset, value.byteLength),
-                        sampleRate: this.sampleRate,
-                        channels: 1,
-                    };
-                }
-            }
-        }
-        finally {
-            reader.releaseLock();
-        }
-    }
-}

package/dist/voice/tts-openai.test.js

@@ -1,138 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { OpenaiTtsProvider } from './tts-openai.js';
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function createLogger() {
-    return { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-}
-/** Build a mock ReadableStream that yields the given byte arrays, then closes. */
-function mockStream(chunks) {
-    let i = 0;
-    return new ReadableStream({
-        pull(controller) {
-            if (i < chunks.length) {
-                controller.enqueue(chunks[i]);
-                i++;
-            }
-            else {
-                controller.close();
-            }
-        },
-    });
-}
-function mockFetch(chunks = [new Uint8Array([1, 2, 3, 4])], ok = true, status = 200) {
-    return vi.fn().mockResolvedValue({
-        ok,
-        status,
-        body: ok ? mockStream(chunks) : null,
-        text: async () => 'API error body',
-    });
-}
-function makeProvider(overrides = {}) {
-    return new OpenaiTtsProvider({
-        apiKey: overrides.apiKey ?? 'test-key',
-        model: overrides.model,
-        voice: overrides.voice,
-        sampleRate: overrides.sampleRate,
-        log: overrides.log ?? createLogger(),
-        fetchFn: overrides.fetchFn ?? mockFetch(),
-    });
-}
-async function collectFrames(iter) {
-    const frames = [];
-    for await (const frame of iter) {
-        frames.push(frame);
-    }
-    return frames;
-}
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-beforeEach(() => {
-    vi.clearAllMocks();
-});
-describe('OpenaiTtsProvider', () => {
-    it('sends correct API request with default model, voice, and pcm format', async () => {
-        const fetchFn = mockFetch([new Uint8Array([10, 20])]);
-        const provider = makeProvider({ fetchFn, apiKey: 'sk-my-key' });
-        await collectFrames(provider.synthesize('hello'));
-        expect(fetchFn).toHaveBeenCalledTimes(1);
-        const [url, init] = vi.mocked(fetchFn).mock.calls[0];
-        expect(url).toBe('https://api.openai.com/v1/audio/speech');
-        expect(init.headers.Authorization).toBe('Bearer sk-my-key');
-        expect(init.headers['Content-Type']).toBe('application/json');
-        const body = JSON.parse(init.body);
-        expect(body.model).toBe('tts-1');
-        expect(body.voice).toBe('alloy');
-        expect(body.input).toBe('hello');
-        expect(body.response_format).toBe('pcm');
-    });
-    it('uses custom model, voice, and sampleRate', async () => {
-        const fetchFn = mockFetch([new Uint8Array([1])]);
-        const provider = makeProvider({
-            fetchFn,
-            model: 'tts-1-hd',
-            voice: 'nova',
-            sampleRate: 48000,
-        });
-        const frames = await collectFrames(provider.synthesize('test'));
-        const body = JSON.parse(vi.mocked(fetchFn).mock.calls[0][1].body);
-        expect(body.model).toBe('tts-1-hd');
-        expect(body.voice).toBe('nova');
-        expect(frames[0].sampleRate).toBe(48000);
-    });
-    it('streams multiple audio frames with correct metadata', async () => {
-        const chunks = [
-            new Uint8Array([1, 2, 3]),
-            new Uint8Array([4, 5, 6]),
-            new Uint8Array([7, 8, 9]),
-        ];
-        const fetchFn = mockFetch(chunks);
-        const provider = makeProvider({ fetchFn });
-        const frames = await collectFrames(provider.synthesize('hello world'));
-        expect(frames).toHaveLength(3);
-        expect([...frames[0].buffer]).toEqual([1, 2, 3]);
-        expect([...frames[1].buffer]).toEqual([4, 5, 6]);
-        expect([...frames[2].buffer]).toEqual([7, 8, 9]);
-        for (const frame of frames) {
-            expect(frame.sampleRate).toBe(24000);
-            expect(frame.channels).toBe(1);
-        }
-    });
-    it('empty text yields no frames and does not call API', async () => {
-        const fetchFn = mockFetch();
-        const provider = makeProvider({ fetchFn });
-        const frames = await collectFrames(provider.synthesize(''));
-        expect(frames).toHaveLength(0);
-        const frames2 = await collectFrames(provider.synthesize('   '));
-        expect(frames2).toHaveLength(0);
-        expect(fetchFn).not.toHaveBeenCalled();
-    });
-    it('throws on non-OK HTTP response', async () => {
-        const fetchFn = mockFetch([], false, 429);
-        const provider = makeProvider({ fetchFn });
-        await expect(collectFrames(provider.synthesize('test'))).rejects.toThrow('OpenAI TTS API error: 429');
-    });
-    it('throws when response has no body stream', async () => {
-        const fetchFn = vi.fn().mockResolvedValue({
-            ok: true,
-            status: 200,
-            body: null,
-            text: async () => '',
-        });
-        const provider = makeProvider({ fetchFn });
-        await expect(collectFrames(provider.synthesize('test'))).rejects.toThrow('response has no body stream');
-    });
-    it('single large chunk yields one frame', async () => {
-        const big = new Uint8Array(16384);
-        big.fill(42);
-        const fetchFn = mockFetch([big]);
-        const provider = makeProvider({ fetchFn });
-        const frames = await collectFrames(provider.synthesize('long text'));
-        expect(frames).toHaveLength(1);
-        expect(frames[0].buffer.length).toBe(16384);
-        expect(frames[0].sampleRate).toBe(24000);
-        expect(frames[0].channels).toBe(1);
-    });
-});