discoclaw 1.3.0 → 2.0.0

package/dist/voice/stt-deepgram.js

@@ -1,154 +0,0 @@
-import WebSocket from 'ws';
-const DEEPGRAM_STREAMING_URL = 'wss://api.deepgram.com/v1/listen';
-const MAX_RETRIES = 3;
-const BASE_BACKOFF_MS = 500;
-export const KEEPALIVE_INTERVAL_MS = 5_000;
-export class DeepgramSttProvider {
-    apiKey;
-    sampleRate;
-    model;
-    log;
-    wsFactory;
-    ws = null;
-    callback = null;
-    state = 'idle';
-    retryCount = 0;
-    feedCount = 0;
-    keepAliveTimer = null;
-    constructor(opts) {
-        this.apiKey = opts.apiKey;
-        this.sampleRate = opts.sampleRate;
-        this.model = opts.model ?? 'nova-3-general';
-        this.log = opts.log;
-        this.wsFactory =
-            opts.wsFactory ?? ((url, headers) => new WebSocket(url, { headers }));
-    }
-    async start() {
-        if (this.state === 'open' || this.state === 'starting')
-            return;
-        this.state = 'starting';
-        this.retryCount = 0;
-        await this.connect();
-    }
-    feedAudio(frame) {
-        if (this.state !== 'open') {
-            throw new Error('Cannot feedAudio before start() or after stop()');
-        }
-        this.feedCount++;
-        if (this.feedCount === 1 || this.feedCount % 100 === 0) {
-            this.log.info({ feedCount: this.feedCount, bufferSize: frame.buffer.length }, 'stt:feedAudio');
-        }
-        this.ws.send(frame.buffer);
-    }
-    onTranscription(callback) {
-        this.callback = callback;
-    }
-    async stop() {
-        this.clearKeepAlive();
-        if (this.state === 'stopped' || this.state === 'idle')
-            return;
-        this.state = 'stopped';
-        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-            this.ws.send(JSON.stringify({ type: 'CloseStream' }));
-            this.ws.close();
-        }
-        this.ws = null;
-    }
-    buildUrl() {
-        const params = new URLSearchParams({
-            model: this.model,
-            encoding: 'linear16',
-            sample_rate: String(this.sampleRate),
-        });
-        return `${DEEPGRAM_STREAMING_URL}?${params.toString()}`;
-    }
-    connect() {
-        this.clearKeepAlive();
-        return new Promise((resolve, reject) => {
-            const url = this.buildUrl();
-            const ws = this.wsFactory(url, {
-                Authorization: `Token ${this.apiKey}`,
-            });
-            this.ws = ws;
-            ws.on('open', () => {
-                this.state = 'open';
-                this.log.info({ url: DEEPGRAM_STREAMING_URL }, 'Deepgram STT connected');
-                this.keepAliveTimer = setInterval(() => {
-                    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-                        this.ws.send(JSON.stringify({ type: 'KeepAlive' }));
-                    }
-                }, KEEPALIVE_INTERVAL_MS);
-                resolve();
-            });
-            ws.on('message', (data) => {
-                this.handleMessage(data);
-            });
-            ws.on('error', (err) => {
-                this.log.error({ err: err.message }, 'Deepgram STT WebSocket error');
-            });
-            ws.on('close', (code, reason) => {
-                if (this.state === 'stopped')
-                    return;
-                // If we were still in the initial connect, reject
-                if (this.state === 'starting') {
-                    reject(new Error(`WebSocket closed during connect: code=${code} reason=${reason.toString()}`));
-                    return;
-                }
-                this.handleUnexpectedClose();
-            });
-        });
-    }
-    handleMessage(data) {
-        try {
-            const parsed = JSON.parse(String(data));
-            // Log all Deepgram messages for debugging
-            const alt = parsed?.channel?.alternatives?.[0];
-            const transcript = alt?.transcript ?? '';
-            this.log.info({
-                type: parsed.type,
-                isFinal: parsed.is_final,
-                speechFinal: parsed.speech_final,
-                transcript: transcript.slice(0, 80),
-            }, 'stt:deepgram message');
-            if (!this.callback)
-                return;
-            if (!alt)
-                return;
-            const result = {
-                text: transcript,
-                confidence: alt.confidence,
-                isFinal: Boolean(parsed.is_final && parsed.speech_final),
-            };
-            this.callback(result);
-        }
-        catch (err) {
-            this.log.error({ err }, 'Failed to parse Deepgram STT message');
-        }
-    }
-    clearKeepAlive() {
-        if (this.keepAliveTimer !== null) {
-            clearInterval(this.keepAliveTimer);
-            this.keepAliveTimer = null;
-        }
-    }
-    handleUnexpectedClose() {
-        this.clearKeepAlive();
-        if (this.retryCount >= MAX_RETRIES) {
-            this.log.error({ retries: this.retryCount }, 'Deepgram STT exhausted reconnect retries');
-            this.state = 'stopped';
-            return;
-        }
-        this.retryCount++;
-        const delay = BASE_BACKOFF_MS * 2 ** (this.retryCount - 1);
-        this.log.warn({ attempt: this.retryCount, maxRetries: MAX_RETRIES, delayMs: delay }, 'Deepgram STT reconnecting after unexpected close');
-        setTimeout(() => {
-            if (this.state === 'stopped')
-                return;
-            this.state = 'starting';
-            this.connect().catch((err) => {
-                this.log.error({ err }, 'Deepgram STT reconnect failed');
-                this.handleUnexpectedClose();
-            });
-        }, delay);
-    }
-}

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

@@ -1,275 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { EventEmitter } from 'node:events';
-import { DeepgramSttProvider, KEEPALIVE_INTERVAL_MS } from './stt-deepgram.js';
-// ---------------------------------------------------------------------------
-// Mock WebSocket (ws-library style: EventEmitter with readyState)
-// ---------------------------------------------------------------------------
-class MockWebSocket extends EventEmitter {
-    static OPEN = 1;
-    static CLOSED = 3;
-    url;
-    headers;
-    readyState = MockWebSocket.OPEN;
-    sent = [];
-    constructor(url, headers) {
-        super();
-        this.url = url;
-        this.headers = headers;
-        // Auto-open on next microtask so callers can attach handlers
-        queueMicrotask(() => this.emit('open'));
-    }
-    send(data) {
-        this.sent.push(data);
-    }
-    close() {
-        this.readyState = MockWebSocket.CLOSED;
-    }
-    // Test helpers
-    _receiveMessage(data) {
-        this.emit('message', JSON.stringify(data));
-    }
-    _triggerClose(code = 1006) {
-        this.readyState = MockWebSocket.CLOSED;
-        this.emit('close', code, Buffer.from(''));
-    }
-    _triggerError(msg = 'test error') {
-        this.emit('error', new Error(msg));
-    }
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function createLogger() {
-    return { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-}
-let lastCreatedWs = null;
-function mockWsFactory(url, headers) {
-    const ws = new MockWebSocket(url, headers);
-    lastCreatedWs = ws;
-    return ws;
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const typedWsFactory = mockWsFactory;
-function makeProvider(overrides = {}) {
-    return new DeepgramSttProvider({
-        apiKey: overrides.apiKey ?? 'test-key',
-        sampleRate: overrides.sampleRate ?? 16000,
-        log: overrides.log ?? createLogger(),
-        wsFactory: typedWsFactory,
-    });
-}
-function makeFrame(data = [0, 1, 2, 3]) {
-    return { buffer: Buffer.from(data), sampleRate: 16000, channels: 1 };
-}
-// Re-export for the retry test's backoff calculation
-const BASE_BACKOFF_MS = 500;
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-beforeEach(() => {
-    vi.clearAllMocks();
-    lastCreatedWs = null;
-});
-describe('DeepgramSttProvider', () => {
-    it('start opens connection with correct URL and auth header', async () => {
-        const provider = makeProvider({ apiKey: 'my-key', sampleRate: 48000 });
-        await provider.start();
-        expect(lastCreatedWs).not.toBeNull();
-        const url = new URL(lastCreatedWs.url);
-        expect(url.protocol).toBe('wss:');
-        expect(url.hostname).toBe('api.deepgram.com');
-        expect(url.pathname).toBe('/v1/listen');
-        expect(url.searchParams.get('model')).toBe('nova-3-general');
-        expect(url.searchParams.get('encoding')).toBe('linear16');
-        expect(url.searchParams.get('sample_rate')).toBe('48000');
-        // Auth is via header, not query param
-        expect(url.searchParams.get('token')).toBeNull();
-        expect(lastCreatedWs.headers.Authorization).toBe('Token my-key');
-    });
-    it('feedAudio sends binary data', async () => {
-        const provider = makeProvider();
-        await provider.start();
-        const frame = makeFrame([10, 20, 30]);
-        provider.feedAudio(frame);
-        expect(lastCreatedWs.sent).toHaveLength(1);
-        expect(lastCreatedWs.sent[0]).toEqual(frame.buffer);
-    });
-    it('parses Deepgram JSON into TranscriptionResult for interim results', async () => {
-        const provider = makeProvider();
-        const results = [];
-        provider.onTranscription((r) => results.push(r));
-        await provider.start();
-        lastCreatedWs._receiveMessage({
-            is_final: false,
-            speech_final: false,
-            channel: { alternatives: [{ transcript: 'hello', confidence: 0.85 }] },
-        });
-        expect(results).toHaveLength(1);
-        expect(results[0]).toEqual({ text: 'hello', confidence: 0.85, isFinal: false });
-    });
-    it('parses Deepgram JSON into TranscriptionResult for final results', async () => {
-        const provider = makeProvider();
-        const results = [];
-        provider.onTranscription((r) => results.push(r));
-        await provider.start();
-        lastCreatedWs._receiveMessage({
-            is_final: true,
-            speech_final: true,
-            channel: { alternatives: [{ transcript: 'hello world', confidence: 0.97 }] },
-        });
-        expect(results).toHaveLength(1);
-        expect(results[0]).toEqual({ text: 'hello world', confidence: 0.97, isFinal: true });
-    });
-    it('isFinal requires both is_final and speech_final', async () => {
-        const provider = makeProvider();
-        const results = [];
-        provider.onTranscription((r) => results.push(r));
-        await provider.start();
-        // is_final true but speech_final false → not final
-        lastCreatedWs._receiveMessage({
-            is_final: true,
-            speech_final: false,
-            channel: { alternatives: [{ transcript: 'partial', confidence: 0.9 }] },
-        });
-        expect(results[0].isFinal).toBe(false);
-    });
-    it('stop sends CloseStream message', async () => {
-        const provider = makeProvider();
-        await provider.start();
-        const ws = lastCreatedWs;
-        await provider.stop();
-        const closeMsg = ws.sent.find((m) => typeof m === 'string' && JSON.parse(m).type === 'CloseStream');
-        expect(closeMsg).toBeDefined();
-    });
-    it('double stop is idempotent', async () => {
-        const provider = makeProvider();
-        await provider.start();
-        await provider.stop();
-        // Should not throw
-        await provider.stop();
-    });
-    it('feedAudio before start throws', () => {
-        const provider = makeProvider();
-        expect(() => provider.feedAudio(makeFrame())).toThrow('Cannot feedAudio before start() or after stop()');
-    });
-    it('reconnect fires on unexpected close up to retry limit', async () => {
-        vi.useFakeTimers();
-        const log = createLogger();
-        const provider = makeProvider({ log });
-        await provider.start();
-        // Trigger unexpected close — should schedule reconnect
-        lastCreatedWs._triggerClose(1006);
-        expect(log.warn).toHaveBeenCalledTimes(1);
-        expect(vi.mocked(log.warn).mock.calls[0][1]).toContain('reconnecting');
-        // Advance past first retry (500ms)
-        await vi.advanceTimersByTimeAsync(500);
-        expect(lastCreatedWs).not.toBeNull();
-        // Trigger another close
-        lastCreatedWs._triggerClose(1006);
-        expect(log.warn).toHaveBeenCalledTimes(2);
-        // Advance past second retry (1000ms)
-        await vi.advanceTimersByTimeAsync(1000);
-        // Trigger third close
-        lastCreatedWs._triggerClose(1006);
-        expect(log.warn).toHaveBeenCalledTimes(3);
-        // Advance past third retry (2000ms)
-        await vi.advanceTimersByTimeAsync(2000);
-        // Fourth close — retries exhausted
-        lastCreatedWs._triggerClose(1006);
-        expect(log.error).toHaveBeenCalled();
-        expect(vi
-            .mocked(log.error)
-            .mock.calls.some((c) => typeof c[1] === 'string' && c[1].includes('exhausted'))).toBe(true);
-        vi.useRealTimers();
-    });
-    it('error is logged after retries exhausted', async () => {
-        vi.useFakeTimers();
-        const log = createLogger();
-        const provider = makeProvider({ log });
-        await provider.start();
-        // Exhaust all 3 retries
-        for (let i = 0; i < 3; i++) {
-            lastCreatedWs._triggerClose(1006);
-            await vi.advanceTimersByTimeAsync(BASE_BACKOFF_MS * 2 ** i);
-        }
-        // Final close after all retries
-        lastCreatedWs._triggerClose(1006);
-        const errorCalls = vi.mocked(log.error).mock.calls;
-        const exhaustedCall = errorCalls.find((c) => typeof c[1] === 'string' && c[1].includes('exhausted reconnect retries'));
-        expect(exhaustedCall).toBeDefined();
-        vi.useRealTimers();
-    });
-    // -------------------------------------------------------------------------
-    // KeepAlive tests
-    // -------------------------------------------------------------------------
-    it('sends KeepAlive text frames on the interval after start', async () => {
-        vi.useFakeTimers();
-        const provider = makeProvider();
-        await provider.start();
-        const ws = lastCreatedWs;
-        // No KeepAlive sent yet (only just connected)
-        const keepAliveBefore = ws.sent.filter((m) => typeof m === 'string' && JSON.parse(m).type === 'KeepAlive');
-        expect(keepAliveBefore).toHaveLength(0);
-        // Advance one interval — should get one KeepAlive
-        await vi.advanceTimersByTimeAsync(KEEPALIVE_INTERVAL_MS);
-        const keepAliveAfter1 = ws.sent.filter((m) => typeof m === 'string' && JSON.parse(m).type === 'KeepAlive');
-        expect(keepAliveAfter1).toHaveLength(1);
-        // Advance another interval — should get a second KeepAlive
-        await vi.advanceTimersByTimeAsync(KEEPALIVE_INTERVAL_MS);
-        const keepAliveAfter2 = ws.sent.filter((m) => typeof m === 'string' && JSON.parse(m).type === 'KeepAlive');
-        expect(keepAliveAfter2).toHaveLength(2);
-        await provider.stop();
-        vi.useRealTimers();
-    });
-    it('stops sending KeepAlive after stop()', async () => {
-        vi.useFakeTimers();
-        const provider = makeProvider();
-        await provider.start();
-        const ws = lastCreatedWs;
-        await provider.stop();
-        // Advance well past the interval — no KeepAlive should appear
-        await vi.advanceTimersByTimeAsync(KEEPALIVE_INTERVAL_MS * 3);
-        const keepAlives = ws.sent.filter((m) => typeof m === 'string' && JSON.parse(m).type === 'KeepAlive');
-        expect(keepAlives).toHaveLength(0);
-        vi.useRealTimers();
-    });
-    it('clears old keepalive timer and starts new one on reconnect', async () => {
-        vi.useFakeTimers();
-        const provider = makeProvider();
-        await provider.start();
-        const ws1 = lastCreatedWs;
-        // Advance to get one KeepAlive on the first connection
-        await vi.advanceTimersByTimeAsync(KEEPALIVE_INTERVAL_MS);
-        const ka1 = ws1.sent.filter((m) => typeof m === 'string' && JSON.parse(m).type === 'KeepAlive');
-        expect(ka1).toHaveLength(1);
-        // Trigger unexpected close → reconnect
-        ws1._triggerClose(1006);
-        await vi.advanceTimersByTimeAsync(BASE_BACKOFF_MS); // first retry backoff
-        const ws2 = lastCreatedWs;
-        expect(ws2).not.toBe(ws1);
-        // Old timer should be cleared — no further KeepAlives on ws1
-        await vi.advanceTimersByTimeAsync(KEEPALIVE_INTERVAL_MS);
-        const ka1After = ws1.sent.filter((m) => typeof m === 'string' && JSON.parse(m).type === 'KeepAlive');
-        expect(ka1After).toHaveLength(1); // still just the original one
-        // New timer should fire on ws2
-        const ka2 = ws2.sent.filter((m) => typeof m === 'string' && JSON.parse(m).type === 'KeepAlive');
-        expect(ka2).toHaveLength(1);
-        await provider.stop();
-        vi.useRealTimers();
-    });
-    it('KeepAlive messages are JSON text strings, not Buffers', async () => {
-        vi.useFakeTimers();
-        const provider = makeProvider();
-        await provider.start();
-        const ws = lastCreatedWs;
-        await vi.advanceTimersByTimeAsync(KEEPALIVE_INTERVAL_MS);
-        const keepAlives = ws.sent.filter((m) => typeof m === 'string' && JSON.parse(m).type === 'KeepAlive');
-        expect(keepAlives).toHaveLength(1);
-        // Must be a string (text frame), not a Buffer (binary frame)
-        expect(typeof keepAlives[0]).toBe('string');
-        expect(keepAlives[0]).not.toBeInstanceOf(Buffer);
-        expect(JSON.parse(keepAlives[0])).toEqual({ type: 'KeepAlive' });
-        await provider.stop();
-        vi.useRealTimers();
-    });
-});

package/dist/voice/stt-factory.js

@@ -1,42 +0,0 @@
-import { DeepgramSttProvider } from './stt-deepgram.js';
-import { OpenaiSttProvider } from './stt-openai.js';
-/**
- * Create an STT 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: `deepgram` (Nova-3 General streaming via WebSocket),
- * `openai` (Whisper API via REST).
- * Planned: `whisper` (local Whisper model, Phase 2b).
- *
- * Requires `DISCOCLAW_VOICE_ENABLED=1` and a provider-specific API key
- * (e.g. `DEEPGRAM_API_KEY`, `OPENAI_API_KEY`). See docs/voice.md for setup.
- */
-export function createSttProvider(config, log) {
-    switch (config.sttProvider) {
-        case 'deepgram': {
-            if (!config.deepgramApiKey) {
-                throw new Error('deepgramApiKey is required when sttProvider is "deepgram"');
-            }
-            return new DeepgramSttProvider({
-                apiKey: config.deepgramApiKey,
-                sampleRate: 16000,
-                model: config.deepgramSttModel,
-                log,
-            });
-        }
-        case 'openai': {
-            if (!config.openaiApiKey) {
-                throw new Error('openaiApiKey is required when sttProvider is "openai"');
-            }
-            return new OpenaiSttProvider({
-                apiKey: config.openaiApiKey,
-                sampleRate: 16000,
-                log,
-            });
-        }
-        case 'whisper':
-            throw new Error('Whisper STT adapter is not yet implemented (Phase 2b)');
-    }
-}

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

@@ -1,45 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { createSttProvider } from './stt-factory.js';
-import { DeepgramSttProvider } from './stt-deepgram.js';
-import { OpenaiSttProvider } from './stt-openai.js';
-// Stub globalThis.WebSocket so DeepgramSttProvider 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',
-        deepgramApiKey: 'test-key',
-        ...overrides,
-    };
-}
-describe('createSttProvider', () => {
-    it('returns a DeepgramSttProvider for deepgram config', () => {
-        const provider = createSttProvider(baseConfig(), createLogger());
-        expect(provider).toBeInstanceOf(DeepgramSttProvider);
-    });
-    it('throws when deepgramApiKey is missing for deepgram provider', () => {
-        expect(() => createSttProvider(baseConfig({ deepgramApiKey: undefined }), createLogger())).toThrow('deepgramApiKey is required');
-    });
-    it('returns an OpenaiSttProvider for openai config', () => {
-        const provider = createSttProvider(baseConfig({ sttProvider: 'openai', openaiApiKey: 'sk-test' }), createLogger());
-        expect(provider).toBeInstanceOf(OpenaiSttProvider);
-    });
-    it('throws when openaiApiKey is missing for openai provider', () => {
-        expect(() => createSttProvider(baseConfig({ sttProvider: 'openai' }), createLogger())).toThrow('openaiApiKey is required');
-    });
-    it('throws not-implemented for whisper provider', () => {
-        expect(() => createSttProvider(baseConfig({ sttProvider: 'whisper' }), createLogger())).toThrow('not yet implemented');
-    });
-});

package/dist/voice/stt-openai.js

@@ -1,156 +0,0 @@
-const OPENAI_TRANSCRIPTIONS_URL = 'https://api.openai.com/v1/audio/transcriptions';
-const DEFAULT_SILENCE_THRESHOLD_MS = 1500;
-const WHISPER_MODEL = 'whisper-1';
-/**
- * OpenAI Whisper STT adapter.
- *
- * Whisper is a batch API — there is no streaming endpoint. This adapter
- * buffers incoming PCM frames and triggers transcription when silence is
- * detected (no new audio for `silenceThresholdMs`). On transcribe, it
- * constructs a minimal WAV header, POSTs to the OpenAI transcriptions
- * endpoint, and fires the `onTranscription` callback with `isFinal: true`.
- * Keep the multipart request shape aligned with the official OpenAI audio
- * transcription docs.
- */
-export class OpenaiSttProvider {
-    apiKey;
-    sampleRate;
-    log;
-    silenceThresholdMs;
-    fetchFn;
-    state = 'idle';
-    callback = null;
-    audioBuffers = [];
-    totalBytes = 0;
-    silenceTimer = null;
-    constructor(opts) {
-        this.apiKey = opts.apiKey;
-        this.sampleRate = opts.sampleRate;
-        this.log = opts.log;
-        this.silenceThresholdMs = opts.silenceThresholdMs ?? DEFAULT_SILENCE_THRESHOLD_MS;
-        this.fetchFn = opts.fetchFn ?? globalThis.fetch;
-    }
-    async start() {
-        if (this.state === 'running')
-            return;
-        this.state = 'running';
-        this.audioBuffers = [];
-        this.totalBytes = 0;
-        this.log.info('OpenAI Whisper STT started');
-    }
-    feedAudio(frame) {
-        if (this.state !== 'running') {
-            throw new Error('Cannot feedAudio before start() or after stop()');
-        }
-        this.audioBuffers.push(frame.buffer);
-        this.totalBytes += frame.buffer.length;
-        // Reset silence timer on every audio frame
-        this.resetSilenceTimer();
-    }
-    onTranscription(callback) {
-        this.callback = callback;
-    }
-    async stop() {
-        if (this.state === 'stopped' || this.state === 'idle')
-            return;
-        this.state = 'stopped';
-        this.clearSilenceTimer();
-        // Transcribe any remaining buffered audio
-        if (this.totalBytes > 0) {
-            await this.transcribeBuffer();
-        }
-        this.audioBuffers = [];
-        this.totalBytes = 0;
-    }
-    resetSilenceTimer() {
-        this.clearSilenceTimer();
-        this.silenceTimer = setTimeout(() => {
-            this.onSilenceDetected();
-        }, this.silenceThresholdMs);
-    }
-    clearSilenceTimer() {
-        if (this.silenceTimer !== null) {
-            clearTimeout(this.silenceTimer);
-            this.silenceTimer = null;
-        }
-    }
-    onSilenceDetected() {
-        if (this.state !== 'running' || this.totalBytes === 0)
-            return;
-        this.transcribeBuffer().catch((err) => {
-            this.log.error({ err }, 'OpenAI Whisper transcription failed');
-        });
-    }
-    async transcribeBuffer() {
-        const pcm = Buffer.concat(this.audioBuffers);
-        this.audioBuffers = [];
-        this.totalBytes = 0;
-        const wav = buildWav(pcm, this.sampleRate, 1);
-        this.log.info({ pcmBytes: pcm.length, wavBytes: wav.length }, 'OpenAI Whisper: sending audio for transcription');
-        try {
-            const formData = new FormData();
-            // Copy into a plain ArrayBuffer so TypeScript accepts it as BlobPart
-            const ab = new ArrayBuffer(wav.byteLength);
-            new Uint8Array(ab).set(new Uint8Array(wav.buffer, wav.byteOffset, wav.byteLength));
-            formData.append('file', new Blob([ab], { type: 'audio/wav' }), 'audio.wav');
-            formData.append('model', WHISPER_MODEL);
-            const response = await this.fetchFn(OPENAI_TRANSCRIPTIONS_URL, {
-                method: 'POST',
-                headers: {
-                    Authorization: `Bearer ${this.apiKey}`,
-                },
-                body: formData,
-            });
-            if (!response.ok) {
-                const body = await response.text();
-                this.log.error({ status: response.status, body: body.slice(0, 200) }, 'OpenAI Whisper API error');
-                return;
-            }
-            const data = (await response.json());
-            const text = data.text?.trim() ?? '';
-            if (text.length === 0) {
-                this.log.info('OpenAI Whisper: empty transcription, skipping callback');
-                return;
-            }
-            this.log.info({ text: text.slice(0, 80) }, 'OpenAI Whisper transcription');
-            if (this.callback) {
-                this.callback({ text, isFinal: true });
-            }
-        }
-        catch (err) {
-            this.log.error({ err }, 'OpenAI Whisper transcription request failed');
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// WAV header construction (PCM s16le mono)
-// ---------------------------------------------------------------------------
-/**
- * Build a minimal WAV file from raw PCM s16le data.
- * 16-bit samples, mono, at the given sample rate.
- */
-export function buildWav(pcm, sampleRate, channels) {
-    const bitsPerSample = 16;
-    const byteRate = sampleRate * channels * (bitsPerSample / 8);
-    const blockAlign = channels * (bitsPerSample / 8);
-    const dataSize = pcm.length;
-    const headerSize = 44;
-    const header = Buffer.alloc(headerSize);
-    // RIFF chunk descriptor
-    header.write('RIFF', 0);
-    header.writeUInt32LE(36 + dataSize, 4); // ChunkSize
-    header.write('WAVE', 8);
-    // fmt sub-chunk
-    header.write('fmt ', 12);
-    header.writeUInt32LE(16, 16); // Subchunk1Size (PCM)
-    header.writeUInt16LE(1, 20); // AudioFormat (1 = PCM)
-    header.writeUInt16LE(channels, 22);
-    header.writeUInt32LE(sampleRate, 24);
-    header.writeUInt32LE(byteRate, 28);
-    header.writeUInt16LE(blockAlign, 32);
-    header.writeUInt16LE(bitsPerSample, 34);
-    // data sub-chunk
-    header.write('data', 36);
-    header.writeUInt32LE(dataSize, 40);
-    return Buffer.concat([header, pcm]);
-}