discoclaw 1.2.4 → 1.3.0

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

@@ -56,6 +56,62 @@ vi.mock('@discordjs/voice', () => ({
     }),
     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.
@@ -148,6 +204,8 @@ function createPipelineOpts(overrides = {}) {
 // ---------------------------------------------------------------------------
 beforeEach(() => {
     vi.clearAllMocks();
+    mockExecuteToolCall.mockReset();
+    mockExecuteToolCall.mockResolvedValue({ result: 'ok', ok: true });
     lastMockPlayer = null;
 });
 describe('AudioPipelineManager', () => {
@@ -616,4 +674,427 @@ describe('AudioPipelineManager', () => {
             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');
+        });
+    });
 });

package/dist/voice/audio-receiver.js

@@ -22,6 +22,7 @@ export class AudioReceiver {
     log;
     createDecoder;
     onUserSpeaking;
+    onUserSilence;
     decoders = new Map();
     running = false;
     constructor(opts) {
@@ -31,6 +32,7 @@ export class AudioReceiver {
         this.log = opts.log;
         this.createDecoder = opts.createDecoder;
         this.onUserSpeaking = opts.onUserSpeaking;
+        this.onUserSilence = opts.onUserSilence;
     }
     /** Begin listening for audio from allowlisted users. */
     start() {
@@ -122,6 +124,12 @@ export class AudioReceiver {
             decoder.destroy();
             this.decoders.delete(userId);
             this.log.info({ userId }, 'cleaned up user audio decoder');
+            try {
+                this.onUserSilence?.(userId);
+            }
+            catch (err) {
+                this.log.error({ err, userId }, 'onUserSilence callback error');
+            }
         }
     }
 }

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

@@ -224,6 +224,22 @@ describe('AudioReceiver', () => {
         expect(decoder.destroy).toHaveBeenCalled();
         expect(log.info).toHaveBeenCalledWith({ userId: '111' }, 'cleaned up user audio decoder');
     });
+    it('calls onUserSilence when a speaking burst ends', () => {
+        const { connection, speakingEmitter, streams } = createMockConnection();
+        const onUserSilence = vi.fn();
+        const recv = new AudioReceiver({
+            connection,
+            allowedUserIds: new Set(['111']),
+            sttProvider: createMockStt(),
+            log: createLogger(),
+            createDecoder: createMockDecoder,
+            onUserSilence,
+        });
+        recv.start();
+        speakingEmitter.emit('start', '111');
+        streams.get('111').emit('end');
+        expect(onUserSilence).toHaveBeenCalledWith('111');
+    });
     it('cleans up decoder on stream error', () => {
         const { connection, speakingEmitter, streams } = createMockConnection();
         const decoder = createMockDecoder();

package/dist/voice/conversation-buffer.js

@@ -45,18 +45,28 @@ export class ConversationBuffer {
         }
     }
     /**
-     * Format the stored turns as a conversation log string.
-     * Returns empty string when the buffer is empty.
+     * Return the stored turns from oldest to newest.
+     * Useful for replaying history into providers that support explicit seeding.
      */
-    getHistory() {
+    toTurns() {
         if (this.count === 0)
-            return '';
-        const lines = [];
-        // Read from oldest to newest.
+            return [];
+        const turns = [];
         const start = this.count < CAPACITY ? 0 : this.head;
         for (let i = 0; i < this.count; i++) {
             const idx = (start + i) % CAPACITY;
             const turn = this.buffer[idx];
+            turns.push({ user: turn.user, assistant: turn.assistant });
+        }
+        return turns;
+    }
+    /**
+     * Format the stored turns as a conversation log string.
+     * Returns empty string when the buffer is empty.
+     */
+    getHistory() {
+        const lines = [];
+        for (const turn of this.toTurns()) {
             lines.push(`[User]: ${turn.user}`);
             lines.push(`[Assistant]: ${turn.assistant}`);
         }