discoclaw 1.2.4 → 2.0.0

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

@@ -1,281 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { OpenaiSttProvider, buildWav } from './stt-openai.js';
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function createLogger() {
-    return { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-}
-function makeFrame(data = [0, 1, 2, 3]) {
-    return { buffer: Buffer.from(data), sampleRate: 16000, channels: 1 };
-}
-function mockFetch(text = 'hello world', ok = true, status = 200) {
-    return vi.fn().mockResolvedValue({
-        ok,
-        status,
-        json: async () => ({ text }),
-        text: async () => (ok ? JSON.stringify({ text }) : 'API error'),
-    });
-}
-function makeProvider(overrides = {}) {
-    return new OpenaiSttProvider({
-        apiKey: overrides.apiKey ?? 'test-key',
-        sampleRate: overrides.sampleRate ?? 16000,
-        log: overrides.log ?? createLogger(),
-        silenceThresholdMs: overrides.silenceThresholdMs ?? 200,
-        fetchFn: overrides.fetchFn ?? mockFetch(),
-    });
-}
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-beforeEach(() => {
-    vi.useFakeTimers();
-});
-afterEach(() => {
-    vi.useRealTimers();
-    vi.restoreAllMocks();
-});
-describe('OpenaiSttProvider', () => {
-    // -- Lifecycle --
-    it('start transitions to running state', async () => {
-        const provider = makeProvider();
-        await provider.start();
-        // Should not throw when feeding after start
-        provider.feedAudio(makeFrame());
-    });
-    it('double start is idempotent', async () => {
-        const log = createLogger();
-        const provider = makeProvider({ log });
-        await provider.start();
-        await provider.start();
-        // info called once for the first start only
-        expect(vi.mocked(log.info).mock.calls.filter((c) => c[0] === 'OpenAI Whisper STT started')).toHaveLength(1);
-    });
-    it('feedAudio before start throws', () => {
-        const provider = makeProvider();
-        expect(() => provider.feedAudio(makeFrame())).toThrow('Cannot feedAudio before start() or after stop()');
-    });
-    it('feedAudio after stop throws', async () => {
-        const provider = makeProvider();
-        await provider.start();
-        await provider.stop();
-        expect(() => provider.feedAudio(makeFrame())).toThrow('Cannot feedAudio before start() or after stop()');
-    });
-    it('stop is idempotent', async () => {
-        const provider = makeProvider();
-        await provider.start();
-        await provider.stop();
-        await provider.stop(); // should not throw
-    });
-    // -- Silence detection --
-    it('triggers transcription after silence threshold', async () => {
-        const fetchFn = mockFetch('hello');
-        const provider = makeProvider({ fetchFn, silenceThresholdMs: 200 });
-        const results = [];
-        provider.onTranscription((r) => results.push(r));
-        await provider.start();
-        provider.feedAudio(makeFrame([1, 2, 3, 4]));
-        // Advance past silence threshold
-        await vi.advanceTimersByTimeAsync(200);
-        expect(fetchFn).toHaveBeenCalledTimes(1);
-        expect(results).toHaveLength(1);
-        expect(results[0]).toEqual({ text: 'hello', isFinal: true });
-    });
-    it('resets silence timer on new audio', async () => {
-        const fetchFn = mockFetch('hello');
-        const provider = makeProvider({ fetchFn, silenceThresholdMs: 200 });
-        await provider.start();
-        provider.feedAudio(makeFrame());
-        // Advance partway (150ms < 200ms threshold)
-        await vi.advanceTimersByTimeAsync(150);
-        expect(fetchFn).not.toHaveBeenCalled();
-        // Feed more audio — resets timer
-        provider.feedAudio(makeFrame());
-        // Advance another 150ms (total 300ms from start, but only 150ms from last audio)
-        await vi.advanceTimersByTimeAsync(150);
-        expect(fetchFn).not.toHaveBeenCalled();
-        // Advance the remaining 50ms to hit threshold from last audio
-        await vi.advanceTimersByTimeAsync(50);
-        expect(fetchFn).toHaveBeenCalledTimes(1);
-    });
-    it('does not trigger transcription when buffer is empty', async () => {
-        const fetchFn = mockFetch();
-        const provider = makeProvider({ fetchFn, silenceThresholdMs: 100 });
-        await provider.start();
-        // Feed then trigger silence so buffer is consumed
-        provider.feedAudio(makeFrame());
-        await vi.advanceTimersByTimeAsync(100);
-        expect(fetchFn).toHaveBeenCalledTimes(1);
-        // Now wait again — no new audio, so no second call
-        await vi.advanceTimersByTimeAsync(200);
-        expect(fetchFn).toHaveBeenCalledTimes(1);
-    });
-    // -- Buffer cleanup --
-    it('clears buffer after transcription', async () => {
-        const fetchFn = mockFetch('first');
-        const provider = makeProvider({ fetchFn, silenceThresholdMs: 100 });
-        const results = [];
-        provider.onTranscription((r) => results.push(r));
-        await provider.start();
-        provider.feedAudio(makeFrame([1, 2]));
-        await vi.advanceTimersByTimeAsync(100);
-        expect(results).toHaveLength(1);
-        // Feed new audio — should only contain the new data
-        vi.mocked(fetchFn).mockResolvedValue({
-            ok: true,
-            status: 200,
-            json: async () => ({ text: 'second' }),
-            text: async () => JSON.stringify({ text: 'second' }),
-        });
-        provider.feedAudio(makeFrame([3, 4]));
-        await vi.advanceTimersByTimeAsync(100);
-        expect(results).toHaveLength(2);
-        expect(results[1].text).toBe('second');
-    });
-    it('stop transcribes remaining buffer', async () => {
-        const fetchFn = mockFetch('final words');
-        const provider = makeProvider({ fetchFn, silenceThresholdMs: 5000 });
-        const results = [];
-        provider.onTranscription((r) => results.push(r));
-        await provider.start();
-        provider.feedAudio(makeFrame([10, 20, 30]));
-        // Stop before silence threshold — should flush remaining buffer
-        await provider.stop();
-        expect(fetchFn).toHaveBeenCalledTimes(1);
-        expect(results).toHaveLength(1);
-        expect(results[0].text).toBe('final words');
-    });
-    it('stop with empty buffer does not call API', async () => {
-        const fetchFn = mockFetch();
-        const provider = makeProvider({ fetchFn });
-        await provider.start();
-        await provider.stop();
-        expect(fetchFn).not.toHaveBeenCalled();
-    });
-    // -- API request format --
-    it('sends correct Authorization header and model', async () => {
-        const fetchFn = mockFetch('test');
-        const provider = makeProvider({ fetchFn, apiKey: 'sk-my-key', silenceThresholdMs: 100 });
-        await provider.start();
-        provider.feedAudio(makeFrame([1, 2, 3, 4]));
-        await vi.advanceTimersByTimeAsync(100);
-        expect(fetchFn).toHaveBeenCalledTimes(1);
-        const [url, init] = vi.mocked(fetchFn).mock.calls[0];
-        expect(url).toBe('https://api.openai.com/v1/audio/transcriptions');
-        expect(init.headers.Authorization).toBe('Bearer sk-my-key');
-        // Verify FormData contains model field
-        const body = init.body;
-        expect(body.get('model')).toBe('whisper-1');
-        // File should be present
-        expect(body.get('file')).toBeTruthy();
-    });
-    it('sends audio as WAV file in FormData', async () => {
-        const fetchFn = mockFetch('test');
-        const provider = makeProvider({ fetchFn, silenceThresholdMs: 100 });
-        await provider.start();
-        provider.feedAudio(makeFrame([10, 20, 30, 40]));
-        await vi.advanceTimersByTimeAsync(100);
-        const [, init] = vi.mocked(fetchFn).mock.calls[0];
-        const body = init.body;
-        const file = body.get('file');
-        expect(file).toBeInstanceOf(Blob);
-        expect(file.type).toBe('audio/wav');
-        // Verify it's a valid WAV (starts with RIFF header)
-        const arrayBuf = await file.arrayBuffer();
-        const header = Buffer.from(arrayBuf).subarray(0, 4).toString('ascii');
-        expect(header).toBe('RIFF');
-    });
-    // -- Callback behavior --
-    it('skips callback for empty transcription', async () => {
-        const fetchFn = mockFetch('');
-        const provider = makeProvider({ fetchFn, silenceThresholdMs: 100 });
-        const results = [];
-        provider.onTranscription((r) => results.push(r));
-        await provider.start();
-        provider.feedAudio(makeFrame());
-        await vi.advanceTimersByTimeAsync(100);
-        expect(fetchFn).toHaveBeenCalledTimes(1);
-        expect(results).toHaveLength(0);
-    });
-    it('skips callback for whitespace-only transcription', async () => {
-        const fetchFn = mockFetch('   ');
-        const provider = makeProvider({ fetchFn, silenceThresholdMs: 100 });
-        const results = [];
-        provider.onTranscription((r) => results.push(r));
-        await provider.start();
-        provider.feedAudio(makeFrame());
-        await vi.advanceTimersByTimeAsync(100);
-        expect(results).toHaveLength(0);
-    });
-    it('fires callback without onTranscription registered (no crash)', async () => {
-        const fetchFn = mockFetch('hello');
-        const provider = makeProvider({ fetchFn, silenceThresholdMs: 100 });
-        // deliberately not calling onTranscription
-        await provider.start();
-        provider.feedAudio(makeFrame());
-        await vi.advanceTimersByTimeAsync(100);
-        // Should not throw
-    });
-    // -- Error handling --
-    it('logs error on non-OK API response', async () => {
-        const fetchFn = mockFetch('', false, 401);
-        const log = createLogger();
-        const provider = makeProvider({ fetchFn, log, silenceThresholdMs: 100 });
-        const results = [];
-        provider.onTranscription((r) => results.push(r));
-        await provider.start();
-        provider.feedAudio(makeFrame());
-        await vi.advanceTimersByTimeAsync(100);
-        expect(results).toHaveLength(0);
-        expect(log.error).toHaveBeenCalledWith(expect.objectContaining({ status: 401 }), 'OpenAI Whisper API error');
-    });
-    it('logs error on fetch rejection', async () => {
-        const fetchFn = vi.fn().mockRejectedValue(new Error('network down'));
-        const log = createLogger();
-        const provider = makeProvider({ fetchFn, log, silenceThresholdMs: 100 });
-        const results = [];
-        provider.onTranscription((r) => results.push(r));
-        await provider.start();
-        provider.feedAudio(makeFrame());
-        await vi.advanceTimersByTimeAsync(100);
-        expect(results).toHaveLength(0);
-        expect(log.error).toHaveBeenCalledWith(expect.objectContaining({ err: expect.any(Error) }), 'OpenAI Whisper transcription request failed');
-    });
-});
-// ---------------------------------------------------------------------------
-// WAV header construction
-// ---------------------------------------------------------------------------
-describe('buildWav', () => {
-    it('produces a valid 44-byte header + PCM data', () => {
-        const pcm = Buffer.from([0x01, 0x02, 0x03, 0x04]);
-        const wav = buildWav(pcm, 16000, 1);
-        expect(wav.length).toBe(44 + 4);
-        // RIFF header
-        expect(wav.subarray(0, 4).toString('ascii')).toBe('RIFF');
-        expect(wav.readUInt32LE(4)).toBe(36 + 4); // ChunkSize
-        expect(wav.subarray(8, 12).toString('ascii')).toBe('WAVE');
-        // fmt sub-chunk
-        expect(wav.subarray(12, 16).toString('ascii')).toBe('fmt ');
-        expect(wav.readUInt32LE(16)).toBe(16); // Subchunk1Size
-        expect(wav.readUInt16LE(20)).toBe(1); // AudioFormat (PCM)
-        expect(wav.readUInt16LE(22)).toBe(1); // NumChannels
-        expect(wav.readUInt32LE(24)).toBe(16000); // SampleRate
-        expect(wav.readUInt32LE(28)).toBe(32000); // ByteRate (16000 * 1 * 2)
-        expect(wav.readUInt16LE(32)).toBe(2); // BlockAlign (1 * 2)
-        expect(wav.readUInt16LE(34)).toBe(16); // BitsPerSample
-        // data sub-chunk
-        expect(wav.subarray(36, 40).toString('ascii')).toBe('data');
-        expect(wav.readUInt32LE(40)).toBe(4); // data size
-        // PCM data follows
-        expect(wav.subarray(44)).toEqual(pcm);
-    });
-    it('handles stereo at 48kHz', () => {
-        const pcm = Buffer.alloc(960); // some audio data
-        const wav = buildWav(pcm, 48000, 2);
-        expect(wav.readUInt16LE(22)).toBe(2); // NumChannels
-        expect(wav.readUInt32LE(24)).toBe(48000); // SampleRate
-        expect(wav.readUInt32LE(28)).toBe(192000); // ByteRate (48000 * 2 * 2)
-        expect(wav.readUInt16LE(32)).toBe(4); // BlockAlign (2 * 2)
-    });
-});

package/dist/voice/tts-cartesia.js

@@ -1,169 +0,0 @@
-import crypto from 'node:crypto';
-const CARTESIA_WS_URL = 'wss://api.cartesia.ai/tts/websocket';
-const DEFAULT_MODEL_ID = 'sonic-3';
-const DEFAULT_SAMPLE_RATE = 24000;
-export class CartesiaTtsProvider {
-    apiKey;
-    voiceId;
-    modelId;
-    sampleRate;
-    log;
-    WsCtor;
-    constructor(opts) {
-        if (typeof globalThis.WebSocket === 'undefined' && !opts.wsConstructor) {
-            throw new Error('globalThis.WebSocket is not available. ' +
-                'Node 22+ includes WebSocket natively. ' +
-                'Upgrade to Node 22+ or pass a wsConstructor option.');
-        }
-        this.apiKey = opts.apiKey;
-        this.voiceId = opts.voiceId ?? 'a0e99841-438c-4a64-b679-ae501e7d6091';
-        this.modelId = opts.modelId ?? DEFAULT_MODEL_ID;
-        this.sampleRate = opts.sampleRate ?? DEFAULT_SAMPLE_RATE;
-        this.log = opts.log;
-        this.WsCtor = opts.wsConstructor ?? globalThis.WebSocket;
-    }
-    async *synthesize(text) {
-        if (!text.trim())
-            return;
-        const url = this.buildUrl();
-        const ws = new this.WsCtor(url);
-        let hasYielded = false;
-        try {
-            await this.waitForOpen(ws);
-            this.log.info({ model: this.modelId, textLength: text.length }, 'Cartesia TTS WebSocket connected, sending request');
-            ws.send(JSON.stringify({
-                context_id: crypto.randomUUID().replace(/-/g, ''),
-                model_id: this.modelId,
-                transcript: text,
-                voice: { mode: 'id', id: this.voiceId },
-                output_format: {
-                    container: 'raw',
-                    encoding: 'pcm_s16le',
-                    sample_rate: this.sampleRate,
-                },
-            }));
-            yield* this.receiveFrames(ws, () => {
-                hasYielded = true;
-            });
-        }
-        catch (err) {
-            if (hasYielded) {
-                throw new Error('Cartesia TTS stream disconnected mid-stream', { cause: err });
-            }
-            throw err;
-        }
-        finally {
-            if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
-                ws.close();
-            }
-        }
-    }
-    buildUrl() {
-        const params = new URLSearchParams({
-            api_key: this.apiKey,
-            cartesia_version: '2024-06-10',
-        });
-        return `${CARTESIA_WS_URL}?${params.toString()}`;
-    }
-    waitForOpen(ws) {
-        return new Promise((resolve, reject) => {
-            ws.onopen = () => resolve();
-            ws.onerror = (event) => {
-                this.log.error({ error: event }, 'Cartesia TTS WebSocket error');
-            };
-            ws.onclose = (event) => {
-                reject(new Error(`Cartesia TTS WebSocket closed before open: code=${event.code}`));
-            };
-        });
-    }
-    receiveFrames(ws, onYield) {
-        const sampleRate = this.sampleRate;
-        const log = this.log;
-        // Buffer for frames received before the consumer pulls them
-        const pending = [];
-        let done = false;
-        let error = null;
-        let notify = null;
-        function wake() {
-            if (notify) {
-                const fn = notify;
-                notify = null;
-                fn();
-            }
-        }
-        ws.onmessage = (event) => {
-            // Cartesia sends JSON messages with base64-encoded audio in msg.data
-            try {
-                const msg = JSON.parse(String(event.data));
-                // Handle error responses from Cartesia
-                // status_code 206 = partial content (normal streaming chunk) — only error on 4xx/5xx
-                if (msg.error || (msg.status_code && msg.status_code >= 400)) {
-                    log.error({ cartesiaError: msg.error, statusCode: msg.status_code }, 'Cartesia TTS error response');
-                    error = new Error(`Cartesia TTS error: ${msg.error ?? `status ${msg.status_code}`}`);
-                    done = true;
-                    wake();
-                    return;
-                }
-                if (msg.data) {
-                    pending.push({
-                        buffer: Buffer.from(msg.data, 'base64'),
-                        sampleRate,
-                        channels: 1,
-                    });
-                    wake();
-                }
-                if (msg.done) {
-                    done = true;
-                    wake();
-                }
-                // Log unrecognized messages that have no data/done/error fields
-                if (!msg.data && !msg.done && !msg.error && !(msg.status_code && msg.status_code < 400)) {
-                    log.warn({ msgType: msg.type, keys: Object.keys(msg).join(',') }, 'Cartesia TTS: unrecognized message');
-                }
-            }
-            catch {
-                // Fallback: raw binary frame (future-proofing)
-                if (event.data instanceof ArrayBuffer) {
-                    pending.push({
-                        buffer: Buffer.from(event.data),
-                        sampleRate,
-                        channels: 1,
-                    });
-                    wake();
-                }
-                else {
-                    log.error('Unexpected Cartesia TTS message format');
-                }
-            }
-        };
-        ws.onclose = (event) => {
-            if (!done) {
-                error = new Error(`Cartesia TTS WebSocket closed unexpectedly: code=${event.code}`);
-            }
-            done = true;
-            wake();
-        };
-        ws.onerror = (event) => {
-            log.error({ error: event }, 'Cartesia TTS WebSocket error');
-        };
-        async function* generate() {
-            while (true) {
-                // Drain pending frames
-                while (pending.length > 0) {
-                    onYield();
-                    yield pending.shift();
-                }
-                if (done) {
-                    if (error)
-                        throw error;
-                    return;
-                }
-                // Wait for new data
-                await new Promise((resolve) => {
-                    notify = resolve;
-                });
-            }
-        }
-        return generate();
-    }
-}

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

@@ -1,228 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { CartesiaTtsProvider } from './tts-cartesia.js';
-class MockWebSocket {
-    static CONNECTING = 0;
-    static OPEN = 1;
-    static CLOSING = 2;
-    static CLOSED = 3;
-    url;
-    readyState = MockWebSocket.OPEN;
-    onopen = null;
-    onmessage = null;
-    onerror = null;
-    onclose = null;
-    sent = [];
-    constructor(url) {
-        this.url = String(url);
-        // Auto-open on next microtask so callers can attach handlers
-        queueMicrotask(() => this.onopen?.({ type: 'open' }));
-    }
-    send(data) {
-        this.sent.push(data);
-    }
-    close() {
-        this.readyState = MockWebSocket.CLOSED;
-    }
-    // Test helpers — sends audio as JSON with base64 (matching real Cartesia API)
-    _receiveAudio(data) {
-        const b64 = Buffer.from(data).toString('base64');
-        this.onmessage?.({ data: JSON.stringify({ type: 'chunk', data: b64 }) });
-    }
-    _receiveJson(obj) {
-        this.onmessage?.({ data: JSON.stringify(obj) });
-    }
-    _triggerClose(code = 1006) {
-        this.readyState = MockWebSocket.CLOSED;
-        this.onclose?.({ code });
-    }
-    _triggerError() {
-        this.onerror?.({ type: 'error' });
-    }
-}
-// Make global WebSocket constants available for readyState checks
-globalThis.WebSocket = MockWebSocket;
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function createLogger() {
-    return { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-}
-let lastCreatedWs = null;
-function wsFactory(url) {
-    const ws = new MockWebSocket(url);
-    lastCreatedWs = ws;
-    return ws;
-}
-const WsConstructor = wsFactory;
-function makeProvider(overrides = {}) {
-    return new CartesiaTtsProvider({
-        apiKey: overrides.apiKey ?? 'test-key',
-        voiceId: overrides.voiceId,
-        modelId: overrides.modelId,
-        sampleRate: overrides.sampleRate,
-        log: overrides.log ?? createLogger(),
-        wsConstructor: WsConstructor,
-    });
-}
-async function collectFrames(iter) {
-    const frames = [];
-    for await (const frame of iter) {
-        frames.push(frame);
-    }
-    return frames;
-}
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-beforeEach(() => {
-    vi.clearAllMocks();
-    lastCreatedWs = null;
-});
-describe('CartesiaTtsProvider', () => {
-    it('constructs correct WebSocket URL with auth params', async () => {
-        const provider = makeProvider({ apiKey: 'my-api-key' });
-        const iter = provider.synthesize('hello');
-        // Start consuming to trigger WebSocket creation
-        const framePromise = collectFrames(iter);
-        // Wait for microtask to open WS
-        await new Promise((r) => setTimeout(r, 10));
-        expect(lastCreatedWs).not.toBeNull();
-        const url = new URL(lastCreatedWs.url);
-        expect(url.protocol).toBe('wss:');
-        expect(url.hostname).toBe('api.cartesia.ai');
-        expect(url.pathname).toBe('/tts/websocket');
-        expect(url.searchParams.get('api_key')).toBe('my-api-key');
-        expect(url.searchParams.get('cartesia_version')).toBe('2024-06-10');
-        // Verify the synthesis request JSON
-        expect(lastCreatedWs.sent).toHaveLength(1);
-        const req = JSON.parse(lastCreatedWs.sent[0]);
-        expect(req.context_id).toMatch(/^[a-f0-9]{32}$/);
-        expect(req.model_id).toBe('sonic-3');
-        expect(req.transcript).toBe('hello');
-        expect(req.output_format.container).toBe('raw');
-        expect(req.output_format.encoding).toBe('pcm_s16le');
-        // End the stream cleanly
-        lastCreatedWs._receiveJson({ done: true });
-        await framePromise;
-    });
-    it('streams multiple audio frames in correct order', async () => {
-        const provider = makeProvider();
-        const iter = provider.synthesize('hello world');
-        const framePromise = collectFrames(iter);
-        await new Promise((r) => setTimeout(r, 10));
-        // Send 3 audio frames
-        lastCreatedWs._receiveAudio([1, 2, 3]);
-        lastCreatedWs._receiveAudio([4, 5, 6]);
-        lastCreatedWs._receiveAudio([7, 8, 9]);
-        lastCreatedWs._receiveJson({ done: true });
-        const frames = await framePromise;
-        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]);
-        // Verify sample rate and channels on each frame
-        for (const frame of frames) {
-            expect(frame.sampleRate).toBe(24000);
-            expect(frame.channels).toBe(1);
-        }
-    });
-    it('connection failure before any frames throws', async () => {
-        // Use a factory that triggers close instead of open (no auto-open)
-        function failWsFactory(url) {
-            const ws = {
-                url: String(url),
-                readyState: 0,
-                onopen: null,
-                onmessage: null,
-                onerror: null,
-                onclose: null,
-                sent: [],
-                send: vi.fn(),
-                close: vi.fn(),
-            };
-            queueMicrotask(() => {
-                ws.readyState = 3;
-                ws.onclose?.({ code: 1006 });
-            });
-            lastCreatedWs = ws;
-            return ws;
-        }
-        const provider = new CartesiaTtsProvider({
-            apiKey: 'key',
-            log: createLogger(),
-            wsConstructor: failWsFactory,
-        });
-        await expect(collectFrames(provider.synthesize('test'))).rejects.toThrow('closed before open');
-    });
-    it('mid-stream disconnect throws without retrying', async () => {
-        const provider = makeProvider();
-        const iter = provider.synthesize('hello');
-        const framePromise = collectFrames(iter);
-        await new Promise((r) => setTimeout(r, 10));
-        // Yield one frame, then disconnect
-        lastCreatedWs._receiveAudio([1, 2, 3]);
-        // Small delay to ensure the frame is consumed
-        await new Promise((r) => setTimeout(r, 5));
-        lastCreatedWs._triggerClose(1006);
-        await expect(framePromise).rejects.toThrow('mid-stream');
-    });
-    it('empty text yields no frames', async () => {
-        const provider = makeProvider();
-        const frames = await collectFrames(provider.synthesize(''));
-        expect(frames).toHaveLength(0);
-        const frames2 = await collectFrames(provider.synthesize('   '));
-        expect(frames2).toHaveLength(0);
-        // No WebSocket should have been created
-        expect(lastCreatedWs).toBeNull();
-    });
-    it('cleanup on early iterator break closes socket', async () => {
-        const provider = makeProvider();
-        const iter = provider.synthesize('hello')[Symbol.asyncIterator]();
-        // Start pulling — triggers WS creation + waitForOpen
-        const nextPromise = iter.next();
-        // Let the microtask fire to open WS
-        await new Promise((r) => setTimeout(r, 10));
-        // Now send audio data so the first next() resolves
-        lastCreatedWs._receiveAudio([1, 2, 3]);
-        const first = await nextPromise;
-        expect(first.done).toBe(false);
-        expect([...first.value.buffer]).toEqual([1, 2, 3]);
-        // Break early via return
-        await iter.return(undefined);
-        // WebSocket should be closed
-        expect(lastCreatedWs.readyState).toBe(MockWebSocket.CLOSED);
-    });
-    it('constructor throws when globalThis.WebSocket unavailable and no wsConstructor', () => {
-        const original = globalThis.WebSocket;
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            globalThis.WebSocket = undefined;
-            expect(() => new CartesiaTtsProvider({
-                apiKey: 'key',
-                log: createLogger(),
-            })).toThrow('Node 22+');
-        }
-        finally {
-            globalThis.WebSocket = original;
-        }
-    });
-    it('uses custom voiceId, modelId, and sampleRate', async () => {
-        const provider = makeProvider({
-            voiceId: 'custom-voice',
-            modelId: 'sonic-4',
-            sampleRate: 48000,
-        });
-        const iter = provider.synthesize('test');
-        const framePromise = collectFrames(iter);
-        await new Promise((r) => setTimeout(r, 10));
-        const req = JSON.parse(lastCreatedWs.sent[0]);
-        expect(req.model_id).toBe('sonic-4');
-        expect(req.voice.id).toBe('custom-voice');
-        expect(req.output_format.sample_rate).toBe(48000);
-        // Send a frame and complete
-        lastCreatedWs._receiveAudio([10, 20]);
-        lastCreatedWs._receiveJson({ done: true });
-        const frames = await framePromise;
-        expect(frames[0].sampleRate).toBe(48000);
-    });
-});