discoclaw 1.3.0 → 2.0.0

package/dist/voice/audio-pipeline.test.js

@@ -1,1100 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { EventEmitter } from 'node:events';
-import { AudioPipelineManager } from './audio-pipeline.js';
-// ---------------------------------------------------------------------------
-// Mock @discordjs/voice — includes AudioPlayer infrastructure for responder
-// ---------------------------------------------------------------------------
-/** Track the last mock player created so tests can manipulate its state. */
-let lastMockPlayer = null;
-function makeMockPlayer() {
-    const emitter = new EventEmitter();
-    const player = {
-        state: { status: 'idle' },
-        play: vi.fn(() => {
-            const old = { ...player.state };
-            player.state = { status: 'playing' };
-            emitter.emit('stateChange', old, player.state);
-        }),
-        stop: vi.fn(() => {
-            if (player.state.status !== 'idle') {
-                const old = { ...player.state };
-                player.state = { status: 'idle' };
-                emitter.emit('stateChange', old, player.state);
-            }
-        }),
-        on: vi.fn((event, listener) => {
-            emitter.on(event, listener);
-            return player;
-        }),
-        removeListener: vi.fn((event, listener) => {
-            emitter.removeListener(event, listener);
-            return player;
-        }),
-    };
-    return player;
-}
-vi.mock('@discordjs/voice', () => ({
-    VoiceConnectionStatus: {
-        Signalling: 'signalling',
-        Connecting: 'connecting',
-        Ready: 'ready',
-        Disconnected: 'disconnected',
-        Destroyed: 'destroyed',
-    },
-    EndBehaviorType: { Manual: 0, AfterSilence: 1, AfterInactivity: 2 },
-    AudioPlayerStatus: {
-        Idle: 'idle',
-        Playing: 'playing',
-        Buffering: 'buffering',
-        Paused: 'paused',
-        AutoPaused: 'autopaused',
-    },
-    StreamType: { Raw: 'raw' },
-    createAudioPlayer: vi.fn(() => {
-        lastMockPlayer = makeMockPlayer();
-        return lastMockPlayer;
-    }),
-    createAudioResource: vi.fn(() => ({ type: 'mock-resource' })),
-}));
-// ---------------------------------------------------------------------------
-// Mock Gemini Live providers
-// ---------------------------------------------------------------------------
-let mockGeminiProvider;
-let mockGeminiResponder;
-vi.mock('./providers/gemini-live-provider.js', () => ({
-    GeminiLiveProvider: vi.fn().mockImplementation(() => {
-        mockGeminiProvider = {
-            connect: vi.fn(async () => { }),
-            disconnect: vi.fn(async () => { }),
-            sendAudio: vi.fn(),
-            sendAudioStreamEnd: vi.fn(),
-            sendInitialHistory: vi.fn(),
-            sendToolResponse: vi.fn(),
-            onEvent: vi.fn(),
-            state: 'open',
-        };
-        return mockGeminiProvider;
-    }),
-}));
-vi.mock('./providers/gemini-live-responder.js', () => ({
-    GeminiLiveResponder: vi.fn().mockImplementation(() => {
-        mockGeminiResponder = {
-            start: vi.fn(),
-            stop: vi.fn(),
-            destroy: vi.fn(),
-        };
-        return mockGeminiResponder;
-    }),
-}));
-// ---------------------------------------------------------------------------
-// Mock tool execution
-// ---------------------------------------------------------------------------
-const mockExecuteToolCall = vi.fn(async () => ({ result: 'ok', ok: true }));
-vi.mock('../runtime/openai-tool-exec.js', () => ({
-    executeToolCall: (...args) => mockExecuteToolCall(...args),
-}));
-vi.mock('../runtime/openai-tool-schemas.js', () => ({
-    OPENAI_TO_DISCO_NAME: {
-        Read: 'Read',
-        Bash: 'Bash',
-        MemoryQuery: 'MemoryQuery',
-        read_file: 'Read',
-        bash: 'Bash',
-    },
-    buildGeminiToolDeclarations: vi.fn((enabledTools, opts) => ({
-        functionDeclarations: enabledTools.map((name) => ({
-            name,
-            ...(opts?.nonBlocking ? { behavior: 'NON_BLOCKING' } : {}),
-        })),
-    })),
-    buildToolSchemas: vi.fn((enabledTools) => enabledTools.map((name) => ({
-        type: 'function',
-        function: { name, description: `${name} tool`, parameters: {} },
-    }))),
-}));
-// We don't want real stt-factory or audio-receiver internals — the pipeline
-// injects a createStt override and AudioReceiver is tested separately.
-// However we do import AudioReceiver for real so the wiring is exercised.
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function createLogger() {
-    return { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-}
-function createMockStt() {
-    const stt = {
-        transcriptionCb: null,
-        start: vi.fn(async () => { }),
-        feedAudio: vi.fn((_frame) => { }),
-        onTranscription: vi.fn((cb) => {
-            stt.transcriptionCb = cb;
-        }),
-        stop: vi.fn(async () => { }),
-    };
-    return stt;
-}
-function createMockDecoder() {
-    return {
-        decode: vi.fn((_packet) => Buffer.alloc(960 * 2 * 2)),
-        destroy: vi.fn(),
-    };
-}
-function createMockConnection() {
-    const stateListeners = [];
-    const speakingEmitter = new EventEmitter();
-    const subscriptions = new Map();
-    const streams = new Map();
-    const conn = {
-        state: { status: 'signalling' },
-        /** Top-level subscribe (used by VoiceResponder to attach AudioPlayer). */
-        subscribe: vi.fn(),
-        receiver: {
-            speaking: speakingEmitter,
-            subscriptions,
-            subscribe: vi.fn((userId) => {
-                const stream = new EventEmitter();
-                streams.set(userId, stream);
-                subscriptions.set(userId, stream);
-                return stream;
-            }),
-        },
-        on: vi.fn((event, listener) => {
-            if (event === 'stateChange')
-                stateListeners.push(listener);
-            return conn;
-        }),
-        _transition(status) {
-            const old = { ...conn.state };
-            conn.state = { status };
-            for (const l of stateListeners)
-                l(old, conn.state);
-        },
-    };
-    return {
-        connection: conn,
-        _transition: conn._transition.bind(conn),
-        speakingEmitter,
-        subscriptions,
-        streams,
-    };
-}
-function baseVoiceConfig(overrides = {}) {
-    return {
-        enabled: true,
-        sttProvider: 'deepgram',
-        ttsProvider: 'cartesia',
-        deepgramApiKey: 'test-key',
-        ...overrides,
-    };
-}
-function createPipelineOpts(overrides = {}) {
-    const mockStt = createMockStt();
-    return {
-        mockStt,
-        log: createLogger(),
-        voiceConfig: baseVoiceConfig(),
-        allowedUserIds: new Set(['111', '222']),
-        createDecoder: () => createMockDecoder(),
-        createStt: () => mockStt,
-        ...overrides,
-    };
-}
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-beforeEach(() => {
-    vi.clearAllMocks();
-    mockExecuteToolCall.mockReset();
-    mockExecuteToolCall.mockResolvedValue({ result: 'ok', ok: true });
-    lastMockPlayer = null;
-});
-describe('AudioPipelineManager', () => {
-    describe('startPipeline / stopPipeline', () => {
-        it('starts STT and receiver for a guild', async () => {
-            const opts = createPipelineOpts();
-            const mgr = new AudioPipelineManager(opts);
-            const { connection } = createMockConnection();
-            await mgr.startPipeline('g1', connection);
-            expect(opts.mockStt.start).toHaveBeenCalled();
-            expect(mgr.hasPipeline('g1')).toBe(true);
-            expect(mgr.activePipelineCount).toBe(1);
-        });
-        it('stopPipeline stops receiver and STT', async () => {
-            const opts = createPipelineOpts();
-            const mgr = new AudioPipelineManager(opts);
-            const { connection } = createMockConnection();
-            await mgr.startPipeline('g1', connection);
-            await mgr.stopPipeline('g1');
-            expect(opts.mockStt.stop).toHaveBeenCalled();
-            expect(mgr.hasPipeline('g1')).toBe(false);
-            expect(mgr.activePipelineCount).toBe(0);
-        });
-        it('stopPipeline is a no-op for unknown guild', async () => {
-            const opts = createPipelineOpts();
-            const mgr = new AudioPipelineManager(opts);
-            // Should not throw
-            await mgr.stopPipeline('unknown');
-            expect(mgr.activePipelineCount).toBe(0);
-        });
-        it('startPipeline stops existing pipeline before restarting', async () => {
-            const stts = [];
-            const opts = createPipelineOpts({
-                createStt: () => {
-                    const stt = createMockStt();
-                    stts.push(stt);
-                    return stt;
-                },
-            });
-            const mgr = new AudioPipelineManager(opts);
-            const { connection } = createMockConnection();
-            await mgr.startPipeline('g1', connection);
-            await mgr.startPipeline('g1', connection);
-            // First STT should have been stopped
-            expect(stts[0].stop).toHaveBeenCalled();
-            // Second STT should be started
-            expect(stts[1].start).toHaveBeenCalled();
-            expect(mgr.activePipelineCount).toBe(1);
-        });
-        it('logs error and does not add pipeline if STT start fails', async () => {
-            const log = createLogger();
-            const failingStt = createMockStt();
-            failingStt.start.mockRejectedValue(new Error('stt connect failed'));
-            const mgr = new AudioPipelineManager({
-                log,
-                voiceConfig: baseVoiceConfig(),
-                allowedUserIds: new Set(['111']),
-                createDecoder: () => createMockDecoder(),
-                createStt: () => failingStt,
-            });
-            const { connection } = createMockConnection();
-            await mgr.startPipeline('g1', connection);
-            expect(mgr.hasPipeline('g1')).toBe(false);
-            expect(log.error).toHaveBeenCalledWith(expect.objectContaining({ guildId: 'g1' }), 'failed to start audio pipeline');
-        });
-        it('logs error if STT stop throws but still removes pipeline', async () => {
-            const log = createLogger();
-            const stt = createMockStt();
-            stt.stop.mockRejectedValue(new Error('stop failed'));
-            const mgr = new AudioPipelineManager({
-                log,
-                voiceConfig: baseVoiceConfig(),
-                allowedUserIds: new Set(['111']),
-                createDecoder: () => createMockDecoder(),
-                createStt: () => stt,
-            });
-            const { connection } = createMockConnection();
-            await mgr.startPipeline('g1', connection);
-            await mgr.stopPipeline('g1');
-            expect(mgr.hasPipeline('g1')).toBe(false);
-            expect(log.error).toHaveBeenCalledWith(expect.objectContaining({ guildId: 'g1' }), 'error stopping STT provider');
-        });
-    });
-    describe('attach', () => {
-        it('starts pipeline when connection transitions to Ready', async () => {
-            const opts = createPipelineOpts();
-            const mgr = new AudioPipelineManager(opts);
-            const { connection, _transition } = createMockConnection();
-            mgr.attach('g1', connection);
-            _transition('ready');
-            // Allow async handler to settle
-            await vi.waitFor(() => {
-                expect(opts.mockStt.start).toHaveBeenCalled();
-            });
-            expect(mgr.hasPipeline('g1')).toBe(true);
-        });
-        it('stops pipeline when connection transitions to Destroyed', async () => {
-            const opts = createPipelineOpts();
-            const mgr = new AudioPipelineManager(opts);
-            const { connection, _transition } = createMockConnection();
-            mgr.attach('g1', connection);
-            _transition('ready');
-            await vi.waitFor(() => {
-                expect(mgr.hasPipeline('g1')).toBe(true);
-            });
-            _transition('destroyed');
-            await vi.waitFor(() => {
-                expect(mgr.hasPipeline('g1')).toBe(false);
-            });
-            expect(opts.mockStt.stop).toHaveBeenCalled();
-        });
-        it('ignores non-Ready/Destroyed transitions', async () => {
-            const opts = createPipelineOpts();
-            const mgr = new AudioPipelineManager(opts);
-            const { connection, _transition } = createMockConnection();
-            mgr.attach('g1', connection);
-            _transition('connecting');
-            // Give it a tick to settle
-            await new Promise((r) => setTimeout(r, 10));
-            expect(mgr.hasPipeline('g1')).toBe(false);
-            expect(opts.mockStt.start).not.toHaveBeenCalled();
-        });
-    });
-    describe('stopAll', () => {
-        it('stops all active pipelines', async () => {
-            const stts = [];
-            const mgr = new AudioPipelineManager({
-                log: createLogger(),
-                voiceConfig: baseVoiceConfig(),
-                allowedUserIds: new Set(['111']),
-                createDecoder: () => createMockDecoder(),
-                createStt: () => {
-                    const stt = createMockStt();
-                    stts.push(stt);
-                    return stt;
-                },
-            });
-            const { connection: conn1 } = createMockConnection();
-            const { connection: conn2 } = createMockConnection();
-            await mgr.startPipeline('g1', conn1);
-            await mgr.startPipeline('g2', conn2);
-            expect(mgr.activePipelineCount).toBe(2);
-            await mgr.stopAll();
-            expect(mgr.activePipelineCount).toBe(0);
-            expect(stts[0].stop).toHaveBeenCalled();
-            expect(stts[1].stop).toHaveBeenCalled();
-        });
-        it('is a no-op when no pipelines are active', async () => {
-            const mgr = new AudioPipelineManager(createPipelineOpts());
-            await mgr.stopAll(); // should not throw
-            expect(mgr.activePipelineCount).toBe(0);
-        });
-    });
-    describe('onTranscription callback', () => {
-        it('forwards transcription results with guildId', async () => {
-            const transcriptions = [];
-            const stt = createMockStt();
-            const mgr = new AudioPipelineManager({
-                log: createLogger(),
-                voiceConfig: baseVoiceConfig(),
-                allowedUserIds: new Set(['111']),
-                createDecoder: () => createMockDecoder(),
-                createStt: () => stt,
-                onTranscription: (guildId, result) => {
-                    transcriptions.push({ guildId, result });
-                },
-            });
-            const { connection } = createMockConnection();
-            await mgr.startPipeline('g1', connection);
-            // STT onTranscription should have been wired up
-            expect(stt.onTranscription).toHaveBeenCalled();
-            // Simulate a transcription from the STT provider
-            const result = {
-                text: 'hello world',
-                isFinal: true,
-                confidence: 0.95,
-            };
-            stt.transcriptionCb(result);
-            expect(transcriptions).toHaveLength(1);
-            expect(transcriptions[0]).toEqual({ guildId: 'g1', result });
-        });
-        it('does not wire onTranscription when no callback is provided', async () => {
-            const stt = createMockStt();
-            const mgr = new AudioPipelineManager({
-                log: createLogger(),
-                voiceConfig: baseVoiceConfig(),
-                allowedUserIds: new Set(['111']),
-                createDecoder: () => createMockDecoder(),
-                createStt: () => stt,
-            });
-            const { connection } = createMockConnection();
-            await mgr.startPipeline('g1', connection);
-            expect(stt.onTranscription).not.toHaveBeenCalled();
-        });
-    });
-    describe('re-entrancy guard', () => {
-        it('prevents infinite recursion when startPipeline is re-entered', async () => {
-            const stt = createMockStt();
-            let startCount = 0;
-            const mgr = new AudioPipelineManager({
-                log: createLogger(),
-                voiceConfig: baseVoiceConfig(),
-                allowedUserIds: new Set(['111']),
-                createDecoder: () => createMockDecoder(),
-                createStt: () => {
-                    startCount++;
-                    return stt;
-                },
-            });
-            const { connection } = createMockConnection();
-            // Simulate what @discordjs/voice does: VoiceConnection.subscribe()
-            // synchronously fires stateChange→Ready, which would re-invoke
-            // startPipeline. We mock this by calling startPipeline again inside
-            // the first invocation via the STT start hook.
-            let reEntryAttempted = false;
-            stt.start.mockImplementation(async () => {
-                // Simulate re-entrant call (as if subscribe triggered onReady)
-                reEntryAttempted = true;
-                await mgr.startPipeline('g1', connection);
-            });
-            await mgr.startPipeline('g1', connection);
-            expect(reEntryAttempted).toBe(true);
-            // Should only have created one STT (the re-entrant call was blocked)
-            expect(startCount).toBe(1);
-            expect(mgr.hasPipeline('g1')).toBe(true);
-        });
-    });
-    describe('hasPipeline / activePipelineCount', () => {
-        it('returns false and 0 when empty', () => {
-            const mgr = new AudioPipelineManager(createPipelineOpts());
-            expect(mgr.hasPipeline('g1')).toBe(false);
-            expect(mgr.activePipelineCount).toBe(0);
-        });
-        it('reflects active pipelines', async () => {
-            const stts = [];
-            const mgr = new AudioPipelineManager({
-                log: createLogger(),
-                voiceConfig: baseVoiceConfig(),
-                allowedUserIds: new Set(['111']),
-                createDecoder: () => createMockDecoder(),
-                createStt: () => {
-                    const stt = createMockStt();
-                    stts.push(stt);
-                    return stt;
-                },
-            });
-            const { connection: conn1 } = createMockConnection();
-            const { connection: conn2 } = createMockConnection();
-            await mgr.startPipeline('g1', conn1);
-            expect(mgr.hasPipeline('g1')).toBe(true);
-            expect(mgr.activePipelineCount).toBe(1);
-            await mgr.startPipeline('g2', conn2);
-            expect(mgr.hasPipeline('g2')).toBe(true);
-            expect(mgr.activePipelineCount).toBe(2);
-            await mgr.stopPipeline('g1');
-            expect(mgr.hasPipeline('g1')).toBe(false);
-            expect(mgr.activePipelineCount).toBe(1);
-        });
-    });
-    describe('transcript mirror integration', () => {
-        function createMockMirror() {
-            return {
-                postUserTranscription: vi.fn(async () => { }),
-                postBotResponse: vi.fn(async () => { }),
-            };
-        }
-        function createMirrorTts() {
-            return {
-                synthesize: vi.fn(async function* (_text) {
-                    yield { buffer: Buffer.alloc(480, 0x42), sampleRate: 24000, channels: 1 };
-                }),
-            };
-        }
-        it('calls postUserTranscription for final transcriptions', async () => {
-            const stt = createMockStt();
-            const mirror = createMockMirror();
-            const mgr = new AudioPipelineManager({
-                log: createLogger(),
-                voiceConfig: baseVoiceConfig(),
-                allowedUserIds: new Set(['111']),
-                createDecoder: () => createMockDecoder(),
-                createStt: () => stt,
-                transcriptMirror: mirror,
-            });
-            const { connection } = createMockConnection();
-            await mgr.startPipeline('g1', connection);
-            stt.transcriptionCb({ text: 'hello world', isFinal: true, confidence: 0.95 });
-            expect(mirror.postUserTranscription).toHaveBeenCalledWith('User', 'hello world');
-        });
-        it('does not call postUserTranscription for non-final transcriptions', async () => {
-            const stt = createMockStt();
-            const mirror = createMockMirror();
-            const mgr = new AudioPipelineManager({
-                log: createLogger(),
-                voiceConfig: baseVoiceConfig(),
-                allowedUserIds: new Set(['111']),
-                createDecoder: () => createMockDecoder(),
-                createStt: () => stt,
-                transcriptMirror: mirror,
-            });
-            const { connection } = createMockConnection();
-            await mgr.startPipeline('g1', connection);
-            stt.transcriptionCb({ text: 'hello', isFinal: false, confidence: 0.5 });
-            expect(mirror.postUserTranscription).not.toHaveBeenCalled();
-        });
-        it('calls postBotResponse when responder gets an AI response', async () => {
-            const stt = createMockStt();
-            const mirror = createMockMirror();
-            const mgr = new AudioPipelineManager({
-                log: createLogger(),
-                voiceConfig: baseVoiceConfig(),
-                allowedUserIds: new Set(['111']),
-                createDecoder: () => createMockDecoder(),
-                createStt: () => stt,
-                invokeAi: async () => 'AI response text',
-                createTts: () => createMirrorTts(),
-                transcriptMirror: mirror,
-                botDisplayName: 'TestBot',
-            });
-            const { connection } = createMockConnection();
-            await mgr.startPipeline('g1', connection);
-            stt.transcriptionCb({ text: 'hello bot', isFinal: true, confidence: 0.95 });
-            await vi.waitFor(() => {
-                expect(mirror.postBotResponse).toHaveBeenCalledWith('TestBot', 'AI response text');
-            });
-        });
-        it('causes no errors when transcript mirror is omitted', async () => {
-            const stt = createMockStt();
-            const log = createLogger();
-            const mgr = new AudioPipelineManager({
-                log,
-                voiceConfig: baseVoiceConfig(),
-                allowedUserIds: new Set(['111']),
-                createDecoder: () => createMockDecoder(),
-                createStt: () => stt,
-                invokeAi: async () => 'response',
-                createTts: () => createMirrorTts(),
-                // No transcriptMirror
-            });
-            const { connection } = createMockConnection();
-            await mgr.startPipeline('g1', connection);
-            stt.transcriptionCb({ text: 'hello', isFinal: true, confidence: 0.95 });
-            // Allow async pipeline to settle
-            await new Promise((r) => setTimeout(r, 50));
-            // No transcript-mirror errors should have been logged
-            for (const call of log.warn.mock.calls) {
-                expect(call[1]).not.toContain('transcript-mirror');
-            }
-            for (const call of log.error.mock.calls) {
-                expect(call[1]).not.toContain('transcript-mirror');
-            }
-        });
-    });
-    describe('barge-in', () => {
-        function createMockTts() {
-            return {
-                synthesize: vi.fn(async function* (_text) {
-                    yield { buffer: Buffer.alloc(480, 0x42), sampleRate: 24000, channels: 1 };
-                }),
-            };
-        }
-        it('calls responder.stop() on non-empty transcription while playing', async () => {
-            const stt = createMockStt();
-            const log = createLogger();
-            const { connection } = createMockConnection();
-            const mgr = new AudioPipelineManager({
-                log,
-                voiceConfig: baseVoiceConfig(),
-                allowedUserIds: new Set(['111']),
-                createDecoder: () => createMockDecoder(),
-                createStt: () => stt,
-                invokeAi: async () => 'response',
-                createTts: () => createMockTts(),
-            });
-            await mgr.startPipeline('g1', connection);
-            // The pipeline created a VoiceResponder which created a mock player
-            const player = lastMockPlayer;
-            expect(player).toBeTruthy();
-            // Simulate the player being in "playing" state (mid-playback)
-            player.state = { status: 'playing' };
-            // Non-empty transcription arrives — should trigger barge-in
-            stt.transcriptionCb({ text: 'stop that', isFinal: false, confidence: 0.9 });
-            expect(player.stop).toHaveBeenCalled();
-            expect(log.info).toHaveBeenCalledWith(expect.objectContaining({ guildId: 'g1' }), 'barge-in detected');
-        });
-        it('does not trigger barge-in for empty transcription while playing (echo case)', async () => {
-            const stt = createMockStt();
-            const log = createLogger();
-            const { connection } = createMockConnection();
-            const mgr = new AudioPipelineManager({
-                log,
-                voiceConfig: baseVoiceConfig(),
-                allowedUserIds: new Set(['111']),
-                createDecoder: () => createMockDecoder(),
-                createStt: () => stt,
-                invokeAi: async () => 'response',
-                createTts: () => createMockTts(),
-            });
-            await mgr.startPipeline('g1', connection);
-            const player = lastMockPlayer;
-            player.state = { status: 'playing' };
-            player.stop.mockClear();
-            // Empty transcription (echo) — must not trigger barge-in
-            stt.transcriptionCb({ text: '', isFinal: false, confidence: 0.0 });
-            expect(player.stop).not.toHaveBeenCalled();
-            expect(log.info).not.toHaveBeenCalledWith(expect.objectContaining({ guildId: 'g1' }), 'barge-in detected');
-        });
-        it('triggers barge-in on interim (non-final) non-empty transcription while playing', async () => {
-            const stt = createMockStt();
-            const log = createLogger();
-            const { connection } = createMockConnection();
-            const mgr = new AudioPipelineManager({
-                log,
-                voiceConfig: baseVoiceConfig(),
-                allowedUserIds: new Set(['111']),
-                createDecoder: () => createMockDecoder(),
-                createStt: () => stt,
-                invokeAi: async () => 'response',
-                createTts: () => createMockTts(),
-            });
-            await mgr.startPipeline('g1', connection);
-            const player = lastMockPlayer;
-            player.state = { status: 'playing' };
-            // Interim transcription with non-empty text — should trigger barge-in
-            stt.transcriptionCb({ text: 'hey wait', isFinal: false, confidence: 0.8 });
-            expect(player.stop).toHaveBeenCalled();
-            expect(log.info).toHaveBeenCalledWith(expect.objectContaining({ guildId: 'g1' }), 'barge-in detected');
-        });
-        it('does not interrupt when player is idle', async () => {
-            const stt = createMockStt();
-            const log = createLogger();
-            const { connection } = createMockConnection();
-            const mgr = new AudioPipelineManager({
-                log,
-                voiceConfig: baseVoiceConfig(),
-                allowedUserIds: new Set(['111']),
-                createDecoder: () => createMockDecoder(),
-                createStt: () => stt,
-                invokeAi: async () => 'response',
-                createTts: () => createMockTts(),
-            });
-            await mgr.startPipeline('g1', connection);
-            const player = lastMockPlayer;
-            // Player is idle (default state)
-            expect(player.state.status).toBe('idle');
-            player.stop.mockClear();
-            // Non-empty transcription while idle — no barge-in needed
-            stt.transcriptionCb({ text: 'hello', isFinal: false, confidence: 0.9 });
-            expect(player.stop).not.toHaveBeenCalled();
-            expect(log.info).not.toHaveBeenCalledWith(expect.objectContaining({ guildId: 'g1' }), 'barge-in detected');
-        });
-        it('works without a responder (no invokeAi configured)', async () => {
-            const stt = createMockStt();
-            const { connection } = createMockConnection();
-            const mgr = new AudioPipelineManager({
-                log: createLogger(),
-                voiceConfig: baseVoiceConfig(),
-                allowedUserIds: new Set(['111']),
-                createDecoder: () => createMockDecoder(),
-                createStt: () => stt,
-                onTranscription: () => { },
-                // No invokeAi — no responder created
-            });
-            await mgr.startPipeline('g1', connection);
-            // Non-empty transcription — should not throw even though there's no responder
-            expect(() => stt.transcriptionCb({ text: 'hello', isFinal: false, confidence: 0.9 })).not.toThrow();
-        });
-    });
-    describe('gemini-live mode', () => {
-        function createGeminiOpts(overrides = {}) {
-            return {
-                log: createLogger(),
-                voiceConfig: baseVoiceConfig(),
-                allowedUserIds: new Set(['111']),
-                createDecoder: () => createMockDecoder(),
-                voiceProvider: 'gemini-live',
-                geminiApiKey: 'test-gemini-key',
-                ...overrides,
-            };
-        }
-        it('creates GeminiLiveProvider and GeminiLiveResponder, skipping STT/TTS', async () => {
-            const opts = createGeminiOpts();
-            const mgr = new AudioPipelineManager(opts);
-            const { connection } = createMockConnection();
-            await mgr.startPipeline('g1', connection);
-            expect(mgr.hasPipeline('g1')).toBe(true);
-            expect(mockGeminiProvider.connect).toHaveBeenCalled();
-            expect(mockGeminiResponder.start).toHaveBeenCalled();
-        });
-        it('passes built systemInstruction into GeminiLiveProvider setup', async () => {
-            const buildGeminiSystemInstruction = vi.fn(async () => 'voice system instruction');
-            const opts = createGeminiOpts({ buildGeminiSystemInstruction });
-            const mgr = new AudioPipelineManager(opts);
-            const { connection } = createMockConnection();
-            const { GeminiLiveProvider: ProviderMock } = await import('./providers/gemini-live-provider.js');
-            await mgr.startPipeline('g1', connection);
-            expect(buildGeminiSystemInstruction).toHaveBeenCalled();
-            const providerCalls = ProviderMock.mock.calls;
-            expect(providerCalls.at(-1)?.[0]).toEqual(expect.objectContaining({
-                systemInstruction: 'voice system instruction',
-            }));
-        });
-        it('backfills and seeds initial history into Gemini Live before audio starts', async () => {
-            const backfill = vi.fn(async () => [
-                { user: 'first user', assistant: 'first reply' },
-                { user: 'second user', assistant: 'second reply' },
-            ]);
-            const opts = createGeminiOpts({ backfill });
-            const mgr = new AudioPipelineManager(opts);
-            const { connection } = createMockConnection();
-            const { GeminiLiveProvider: ProviderMock } = await import('./providers/gemini-live-provider.js');
-            await mgr.startPipeline('g1', connection);
-            const providerCalls = ProviderMock.mock.calls;
-            expect(providerCalls.at(-1)?.[0]).toEqual(expect.objectContaining({
-                initialHistoryInClientContent: true,
-            }));
-            expect(mockGeminiProvider.sendInitialHistory).toHaveBeenCalledWith([
-                { role: 'user', parts: [{ text: 'first user' }] },
-                { role: 'model', parts: [{ text: 'first reply' }] },
-                { role: 'user', parts: [{ text: 'second user' }] },
-                { role: 'model', parts: [{ text: 'second reply' }] },
-            ]);
-        });
-        it('uses synchronous tool declarations for the default 3.1 live model', async () => {
-            const opts = createGeminiOpts({ enabledTools: ['Read', 'Bash'] });
-            const mgr = new AudioPipelineManager(opts);
-            const { connection } = createMockConnection();
-            const toolSchemas = await import('../runtime/openai-tool-schemas.js');
-            const { GeminiLiveProvider: ProviderMock } = await import('./providers/gemini-live-provider.js');
-            await mgr.startPipeline('g1', connection);
-            expect(toolSchemas.buildGeminiToolDeclarations).toHaveBeenCalledWith(['Read', 'Bash'], { nonBlocking: false });
-            const providerCalls = ProviderMock.mock.calls;
-            expect(providerCalls.at(-1)?.[0]).toEqual(expect.objectContaining({
-                model: 'gemini-3.1-flash-live-preview',
-            }));
-        });
-        it('preserves NON_BLOCKING tool declarations for explicit 2.5 live models', async () => {
-            const opts = createGeminiOpts({
-                enabledTools: ['Read'],
-                runtimeModel: 'gemini-2.5-flash-live-preview',
-            });
-            const mgr = new AudioPipelineManager(opts);
-            const { connection } = createMockConnection();
-            const toolSchemas = await import('../runtime/openai-tool-schemas.js');
-            const { GeminiLiveProvider: ProviderMock } = await import('./providers/gemini-live-provider.js');
-            await mgr.startPipeline('g1', connection);
-            expect(toolSchemas.buildGeminiToolDeclarations).toHaveBeenCalledWith(['Read'], { nonBlocking: true });
-            const providerCalls = ProviderMock.mock.calls;
-            expect(providerCalls.at(-1)?.[0]).toEqual(expect.objectContaining({
-                model: 'gemini-2.5-flash-live-preview',
-            }));
-        });
-        it('calls provider.disconnect() and responder.destroy() on stopPipeline', async () => {
-            const opts = createGeminiOpts();
-            const mgr = new AudioPipelineManager(opts);
-            const { connection } = createMockConnection();
-            await mgr.startPipeline('g1', connection);
-            await mgr.stopPipeline('g1');
-            expect(mockGeminiResponder.destroy).toHaveBeenCalled();
-            expect(mockGeminiProvider.disconnect).toHaveBeenCalled();
-            expect(mgr.hasPipeline('g1')).toBe(false);
-        });
-        it('shim feedAudio bridges to provider.sendAudio', async () => {
-            const opts = createGeminiOpts();
-            const mgr = new AudioPipelineManager(opts);
-            const { connection, speakingEmitter, streams } = createMockConnection();
-            await mgr.startPipeline('g1', connection);
-            // Simulate a user speaking — trigger the receiver to subscribe
-            speakingEmitter.emit('start', '111');
-            // Feed a packet through the stream to exercise the shim
-            const stream = streams.get('111');
-            if (stream) {
-                stream.emit('data', Buffer.alloc(80));
-            }
-            // Allow async processing
-            await new Promise((r) => setTimeout(r, 20));
-            // The shim feedAudio calls provider.sendAudio
-            expect(mockGeminiProvider.sendAudio).toHaveBeenCalled();
-        });
-        it('shim swallows sendAudio errors without crashing', async () => {
-            const log = createLogger();
-            const opts = createGeminiOpts({ log });
-            const mgr = new AudioPipelineManager(opts);
-            const { connection, speakingEmitter, streams } = createMockConnection();
-            await mgr.startPipeline('g1', connection);
-            // Make sendAudio throw
-            mockGeminiProvider.sendAudio.mockImplementation(() => {
-                throw new Error('WebSocket not open');
-            });
-            // Simulate a user speaking
-            speakingEmitter.emit('start', '111');
-            const stream = streams.get('111');
-            if (stream) {
-                stream.emit('data', Buffer.alloc(80));
-            }
-            await new Promise((r) => setTimeout(r, 20));
-            // Should have logged a warning but not thrown
-            expect(log.warn).toHaveBeenCalledWith(expect.objectContaining({ guildId: 'g1' }), 'gemini-live: sendAudio error (non-fatal)');
-        });
-        it('signals audioStreamEnd when a user speaking burst ends', async () => {
-            const opts = createGeminiOpts();
-            const mgr = new AudioPipelineManager(opts);
-            const { connection, speakingEmitter, streams } = createMockConnection();
-            await mgr.startPipeline('g1', connection);
-            speakingEmitter.emit('start', '111');
-            streams.get('111').emit('end');
-            expect(mockGeminiProvider.sendAudioStreamEnd).toHaveBeenCalled();
-        });
-        it('throws when geminiApiKey is missing', async () => {
-            const log = createLogger();
-            const opts = createGeminiOpts({ geminiApiKey: undefined, log });
-            const mgr = new AudioPipelineManager(opts);
-            const { connection } = createMockConnection();
-            await mgr.startPipeline('g1', connection);
-            expect(mgr.hasPipeline('g1')).toBe(false);
-            expect(log.error).toHaveBeenCalledWith(expect.objectContaining({ guildId: 'g1' }), 'failed to start audio pipeline');
-        });
-        it('default voiceProvider unset uses standard pipeline path', async () => {
-            // No voiceProvider set — should use the normal STT path
-            const mockStt = createMockStt();
-            const opts = createPipelineOpts({ createStt: () => mockStt });
-            const mgr = new AudioPipelineManager(opts);
-            const { connection } = createMockConnection();
-            await mgr.startPipeline('g1', connection);
-            expect(mockStt.start).toHaveBeenCalled();
-            expect(mgr.hasPipeline('g1')).toBe(true);
-        });
-        it('wires onBotResponse to transcriptMirror.postBotResponse', async () => {
-            const mirror = {
-                postUserTranscription: vi.fn(async () => { }),
-                postBotResponse: vi.fn(async () => { }),
-            };
-            const opts = createGeminiOpts({
-                transcriptMirror: mirror,
-                botDisplayName: 'GeminiBot',
-            });
-            const mgr = new AudioPipelineManager(opts);
-            const { connection } = createMockConnection();
-            // Access the GeminiLiveResponder constructor mock to check the onBotResponse option
-            const { GeminiLiveResponder: ResponderMock } = await import('./providers/gemini-live-responder.js');
-            await mgr.startPipeline('g1', connection);
-            // Extract the onBotResponse callback passed to GeminiLiveResponder
-            const constructorCalls = ResponderMock.mock.calls;
-            const lastCall = constructorCalls[constructorCalls.length - 1];
-            const responderOpts = lastCall[0];
-            expect(responderOpts.onBotResponse).toBeDefined();
-            responderOpts.onBotResponse('Hello from Gemini');
-            await vi.waitFor(() => {
-                expect(mirror.postBotResponse).toHaveBeenCalledWith('GeminiBot', 'Hello from Gemini');
-            });
-        });
-        it('records completed Gemini Live turns in the local conversation buffer', async () => {
-            const backfill = vi.fn(async () => []);
-            const opts = createGeminiOpts({ backfill });
-            const mgr = new AudioPipelineManager(opts);
-            const { connection } = createMockConnection();
-            const { GeminiLiveResponder: ResponderMock } = await import('./providers/gemini-live-responder.js');
-            await mgr.startPipeline('g1', connection);
-            const constructorCalls = ResponderMock.mock.calls;
-            const lastCall = constructorCalls[constructorCalls.length - 1];
-            const responderOpts = lastCall[0];
-            responderOpts.onInputTranscript?.('hello there');
-            responderOpts.onBotResponse?.('general kenobi');
-            expect(backfill).toHaveBeenCalled();
-            const pipeline = mgr.pipelines.get('g1');
-            expect(pipeline?.buffer?.getHistory()).toContain('[User]: hello there');
-            expect(pipeline?.buffer?.getHistory()).toContain('[Assistant]: general kenobi');
-        });
-        it('wires onInputTranscript to transcriptMirror.postUserTranscription', async () => {
-            const mirror = {
-                postUserTranscription: vi.fn(async () => { }),
-                postBotResponse: vi.fn(async () => { }),
-            };
-            const opts = createGeminiOpts({
-                transcriptMirror: mirror,
-            });
-            const mgr = new AudioPipelineManager(opts);
-            const { connection } = createMockConnection();
-            const { GeminiLiveResponder: ResponderMock } = await import('./providers/gemini-live-responder.js');
-            await mgr.startPipeline('g1', connection);
-            // Extract the onInputTranscript callback passed to GeminiLiveResponder
-            const constructorCalls = ResponderMock.mock.calls;
-            const lastCall = constructorCalls[constructorCalls.length - 1];
-            const responderOpts = lastCall[0];
-            expect(responderOpts.onInputTranscript).toBeDefined();
-            responderOpts.onInputTranscript('hello from user');
-            await vi.waitFor(() => {
-                expect(mirror.postUserTranscription).toHaveBeenCalledWith('User', 'hello from user');
-            });
-        });
-        // -----------------------------------------------------------------------
-        // Tool call dispatch tests
-        // -----------------------------------------------------------------------
-        /** Helper: extract the onToolCall callback from the GeminiLiveResponder constructor mock. */
-        async function extractOnToolCall(overrides = {}) {
-            const opts = createGeminiOpts({
-                enabledTools: ['Read', 'Bash'],
-                runtimeCwd: '/fake/cwd',
-                ...overrides,
-            });
-            const mgr = new AudioPipelineManager(opts);
-            const { connection } = createMockConnection();
-            const { GeminiLiveResponder: ResponderMock } = await import('./providers/gemini-live-responder.js');
-            await mgr.startPipeline('g1', connection);
-            const constructorCalls = ResponderMock.mock.calls;
-            const lastCall = constructorCalls[constructorCalls.length - 1];
-            const responderOpts = lastCall[0];
-            return responderOpts.onToolCall;
-        }
-        it('dispatches tool call to executor and sends response back via provider', async () => {
-            mockExecuteToolCall.mockResolvedValueOnce({ result: 'file contents here', ok: true });
-            const onToolCall = await extractOnToolCall();
-            onToolCall([{ id: 'tc-1', name: 'Read', args: { file_path: '/foo.txt' } }]);
-            await vi.waitFor(() => {
-                expect(mockExecuteToolCall).toHaveBeenCalledWith('Read', { file_path: '/foo.txt' }, ['/fake/cwd'], expect.any(Function), expect.objectContaining({ enableHybridPipeline: false }));
-                expect(mockGeminiProvider.sendToolResponse).toHaveBeenCalledWith([
-                    { id: 'tc-1', name: 'Read', output: 'file contents here' },
-                ]);
-            });
-        });
-        it('returns error result string to Gemini when executor throws', async () => {
-            mockExecuteToolCall.mockRejectedValueOnce(new Error('permission denied'));
-            const onToolCall = await extractOnToolCall();
-            onToolCall([{ id: 'tc-err', name: 'Read', args: {} }]);
-            await vi.waitFor(() => {
-                expect(mockGeminiProvider.sendToolResponse).toHaveBeenCalledWith([
-                    { id: 'tc-err', name: 'Read', output: 'Error: permission denied' },
-                ]);
-            });
-        });
-        it('returns error for unknown tool name (executor rejects non-allowlisted tool)', async () => {
-            mockExecuteToolCall.mockResolvedValueOnce({ result: 'Tool not allowed: UnknownTool', ok: false });
-            const onToolCall = await extractOnToolCall();
-            onToolCall([{ id: 'tc-unk', name: 'UnknownTool', args: {} }]);
-            await vi.waitFor(() => {
-                expect(mockGeminiProvider.sendToolResponse).toHaveBeenCalledWith([
-                    { id: 'tc-unk', name: 'UnknownTool', output: 'Tool not allowed: UnknownTool' },
-                ]);
-            });
-        });
-        it('dispatches multiple function calls and sends all responses in one sendToolResponse', async () => {
-            mockExecuteToolCall
-                .mockResolvedValueOnce({ result: 'result-A', ok: true })
-                .mockResolvedValueOnce({ result: 'result-B', ok: true });
-            const onToolCall = await extractOnToolCall();
-            onToolCall([
-                { id: 'tc-a', name: 'Read', args: { file_path: '/a.txt' } },
-                { id: 'tc-b', name: 'Bash', args: { command: 'ls' } },
-            ]);
-            await vi.waitFor(() => {
-                expect(mockExecuteToolCall).toHaveBeenCalledTimes(2);
-                expect(mockGeminiProvider.sendToolResponse).toHaveBeenCalledWith([
-                    { id: 'tc-a', name: 'Read', output: 'result-A' },
-                    { id: 'tc-b', name: 'Bash', output: 'result-B' },
-                ]);
-            });
-        });
-        it('catches and logs sendToolResponse throw without crashing', async () => {
-            mockExecuteToolCall.mockResolvedValueOnce({ result: 'ok', ok: true });
-            const log = createLogger();
-            const onToolCall = await extractOnToolCall({ log });
-            mockGeminiProvider.sendToolResponse.mockImplementation(() => {
-                throw new Error('WebSocket closed');
-            });
-            onToolCall([{ id: 'tc-disc', name: 'Read', args: {} }]);
-            await vi.waitFor(() => {
-                expect(log.warn).toHaveBeenCalledWith(expect.objectContaining({ guildId: 'g1' }), 'gemini-live: sendToolResponse failed (provider likely disconnected)');
-            });
-        });
-        // -----------------------------------------------------------------------
-        // Scheduled tool responses
-        // -----------------------------------------------------------------------
-        it('ignores silent tool scheduling on the default 3.1 live model', async () => {
-            mockExecuteToolCall.mockResolvedValue({ result: 'memory contents', ok: true });
-            const log = createLogger();
-            const opts = createGeminiOpts({
-                log,
-                enabledTools: ['Read', 'MemoryQuery'],
-                silentTools: ['MemoryQuery'],
-                runtimeCwd: '/fake/cwd',
-            });
-            const mgr = new AudioPipelineManager(opts);
-            const { connection } = createMockConnection();
-            const { GeminiLiveResponder: ResponderMock } = await import('./providers/gemini-live-responder.js');
-            await mgr.startPipeline('g1', connection);
-            const constructorCalls = ResponderMock.mock.calls;
-            const lastCall = constructorCalls[constructorCalls.length - 1];
-            const responderOpts = lastCall[0];
-            // Dispatch a SILENT tool call
-            responderOpts.onToolCall([{ id: 'tc-silent', name: 'MemoryQuery', args: { key: 'test' } }]);
-            await vi.waitFor(() => {
-                expect(mockGeminiProvider.sendToolResponse).toHaveBeenCalledWith([
-                    { id: 'tc-silent', name: 'MemoryQuery', output: 'memory contents' },
-                ]);
-            });
-            expect(log.info).toHaveBeenCalledWith(expect.objectContaining({
-                guildId: 'g1',
-                model: 'gemini-3.1-flash-live-preview',
-                count: 1,
-            }), 'gemini-live: current model does not support scheduled tool responses; silent tool scheduling disabled');
-        });
-        it('sends SILENT-scheduled tool responses for explicit 2.5 live models', async () => {
-            mockExecuteToolCall
-                .mockResolvedValueOnce({ result: 'memory data', ok: true });
-            const log = createLogger();
-            const opts = createGeminiOpts({
-                log,
-                enabledTools: ['MemoryQuery'],
-                silentTools: ['MemoryQuery'],
-                runtimeCwd: '/fake/cwd',
-                runtimeModel: 'gemini-2.5-flash-live-preview',
-            });
-            const mgr = new AudioPipelineManager(opts);
-            const { connection } = createMockConnection();
-            const { GeminiLiveResponder: ResponderMock } = await import('./providers/gemini-live-responder.js');
-            await mgr.startPipeline('g1', connection);
-            const constructorCalls = ResponderMock.mock.calls;
-            const lastCall = constructorCalls[constructorCalls.length - 1];
-            const responderOpts = lastCall[0];
-            responderOpts.onToolCall([
-                { id: 'tc-mem', name: 'MemoryQuery', args: { key: 'test' } },
-            ]);
-            await vi.waitFor(() => {
-                expect(mockExecuteToolCall).toHaveBeenCalledTimes(1);
-                expect(log.info).toHaveBeenCalledWith(expect.objectContaining({ guildId: 'g1', count: 1 }), 'gemini-live: SILENT tool execution complete — results scheduled silently');
-                expect(mockGeminiProvider.sendToolResponse).toHaveBeenCalledWith([
-                    { id: 'tc-mem', name: 'MemoryQuery', output: 'memory data', scheduling: 'SILENT' },
-                ]);
-            });
-        });
-        // -----------------------------------------------------------------------
-        // Fallback to standard pipeline
-        // -----------------------------------------------------------------------
-        it('does not fall back when initial gemini-live connection fails (fallback disabled)', async () => {
-            const { GeminiLiveProvider: ProviderMock } = await import('./providers/gemini-live-provider.js');
-            // Make the next provider's connect() reject
-            ProviderMock.mockImplementationOnce(() => {
-                mockGeminiProvider = {
-                    connect: vi.fn(async () => { throw new Error('connection refused'); }),
-                    disconnect: vi.fn(async () => { }),
-                    sendAudio: vi.fn(),
-                    sendAudioStreamEnd: vi.fn(),
-                    sendInitialHistory: vi.fn(),
-                    sendToolResponse: vi.fn(),
-                    onEvent: vi.fn(),
-                    state: 'idle',
-                };
-                return mockGeminiProvider;
-            });
-            const log = createLogger();
-            const opts = createGeminiOpts({ log });
-            const mgr = new AudioPipelineManager(opts);
-            const { connection } = createMockConnection();
-            await mgr.startPipeline('g1', connection);
-            expect(mgr.hasPipeline('g1')).toBe(false);
-            expect(log.error).toHaveBeenCalledWith(expect.objectContaining({ guildId: 'g1' }), 'gemini-live: connection failed — no fallback (fallback disabled)');
-        });
-        it('does not fall back when onSessionTerminated is triggered (fallback disabled)', async () => {
-            const log = createLogger();
-            const opts = createGeminiOpts({ log });
-            const mgr = new AudioPipelineManager(opts);
-            const { connection } = createMockConnection();
-            const { GeminiLiveResponder: ResponderMock } = await import('./providers/gemini-live-responder.js');
-            await mgr.startPipeline('g1', connection);
-            expect(mgr.pipelineMode('g1')).toBe('gemini-live');
-            // Extract onSessionTerminated callback
-            const constructorCalls = ResponderMock.mock.calls;
-            const lastCall = constructorCalls[constructorCalls.length - 1];
-            const responderOpts = lastCall[0];
-            expect(responderOpts.onSessionTerminated).toBeDefined();
-            responderOpts.onSessionTerminated();
-            // Pipeline should NOT switch to standard mode — it stays as gemini-live (or gets stopped)
-            expect(log.error).toHaveBeenCalledWith(expect.objectContaining({ guildId: 'g1' }), 'gemini-live session terminally failed — no fallback (fallback disabled)');
-        });
-        it('does not fall back when onFallbackRecommended is triggered (fallback disabled)', async () => {
-            const log = createLogger();
-            const opts = createGeminiOpts({ log });
-            const mgr = new AudioPipelineManager(opts);
-            const { connection } = createMockConnection();
-            const { GeminiLiveResponder: ResponderMock } = await import('./providers/gemini-live-responder.js');
-            await mgr.startPipeline('g1', connection);
-            // Extract onFallbackRecommended callback
-            const constructorCalls = ResponderMock.mock.calls;
-            const lastCall = constructorCalls[constructorCalls.length - 1];
-            const responderOpts = lastCall[0];
-            expect(responderOpts.onFallbackRecommended).toBeDefined();
-            responderOpts.onFallbackRecommended('exhausted reconnect retries');
-            // Pipeline should NOT switch to standard mode
-            expect(log.warn).toHaveBeenCalledWith(expect.objectContaining({ guildId: 'g1', reason: 'exhausted reconnect retries' }), 'gemini-live: fallback recommended but fallback is disabled');
-        });
-    });
-});