factory-factory 0.4.7 → 0.4.9

package/dist/src/backend/services/session/service/voice/voice-narration.service.test.js

@@ -30,7 +30,11 @@ const FakeDeepgramSocket = vi.hoisted(() => {
             if (event === 'open') {
                 this.readyState = FakeDeepgramSocket.OPEN;
             }
-            for (const handler of this.listeners.get(event) ?? []) {
+            const handlers = this.listeners.get(event) ?? [];
+            if (event === 'error' && handlers.length === 0) {
+                throw args[0] instanceof Error ? args[0] : new Error('Unhandled error event');
+            }
+            for (const handler of handlers) {
                 handler(...args);
             }
         }
@@ -42,13 +46,17 @@ const FakeDeepgramSocket = vi.hoisted(() => {
             this.sentMessages.push(data);
         }
         close() {
+            const wasConnecting = this.readyState === FakeDeepgramSocket.CONNECTING;
             this.readyState = FakeDeepgramSocket.CLOSED;
+            if (wasConnecting) {
+                this.emit('error', new Error('WebSocket was closed before the connection was established'));
+            }
         }
     }
     return FakeDeepgramSocket;
 });
 vi.mock('ws', () => ({ default: FakeDeepgramSocket }));
-import { SESSION_OUTBOUND_EVENT, sessionEventBus, } from '../../../../../backend/services/session/service/session-event-bus.js';
+import { SESSION_OUTBOUND_EVENT, sessionEventBus, } from '../session-event-bus.js';
 import { voiceNarrationService } from './voice-narration.service.js';
 function createFakeClientWs(bufferedAmount = 0) {
     return {
@@ -76,12 +84,19 @@ function emitThinking(sessionId, thinking) {
         },
     });
 }
+function emitFinalText(sessionId, text) {
+    emitDelta(sessionId, {
+        type: 'session_delta',
+        data: { type: 'assistant_text_delta', text },
+    });
+}
 function emitRuntimeUpdate(sessionId, activity) {
     emitDelta(sessionId, {
         type: 'session_delta',
         data: { type: 'session_runtime_updated', sessionRuntime: { activity } },
     });
 }
+const socketAt = (index) => FakeDeepgramSocket.instances[index];
 const liveConnections = [];
 function register(sessionId, ws) {
     voiceNarrationService.registerConnection(sessionId, ws);
@@ -101,7 +116,7 @@ describe('voiceNarrationService', () => {
         mockUserSettingsService.get.mockResolvedValue({
             voiceModeEnabled: true,
             deepgramApiKeyEncrypted: 'enc:dg_secret',
-            voiceTtsModel: 'aura-2-thalia-en',
+            voiceTtsModel: 'flux-haley-en',
             voiceTtsSpeed: 1,
         });
     });
@@ -132,12 +147,9 @@ describe('voiceNarrationService', () => {
         register('sess-reconnect', firstWs);
         register('sess-reconnect', secondWs);
         unregister('sess-reconnect', firstWs);
-        emitDelta('sess-reconnect', {
-            type: 'session_delta',
-            data: { type: 'assistant_text_delta', text: 'still connected. ' },
-        });
+        emitFinalText('sess-reconnect', 'still connected. ');
         await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
-        const ttsSocket = FakeDeepgramSocket.instances[0];
+        const ttsSocket = socketAt(0);
         ttsSocket.emit('open');
         ttsSocket.emit('message', Buffer.from([9]), true);
         expect(secondWs.send).toHaveBeenCalled();
@@ -147,10 +159,7 @@ describe('voiceNarrationService', () => {
     it('resets accumulated text when a new turn starts (activity WORKING)', async () => {
         const clientWs = createFakeClientWs();
         register('sess-reset', clientWs);
-        emitDelta('sess-reset', {
-            type: 'session_delta',
-            data: { type: 'assistant_text_delta', text: 'stale answer' },
-        });
+        emitFinalText('sess-reset', 'stale answer');
         emitRuntimeUpdate('sess-reset', 'WORKING');
         emitRuntimeUpdate('sess-reset', 'IDLE');
         await new Promise((resolve) => setTimeout(resolve, 0));
@@ -164,10 +173,7 @@ describe('voiceNarrationService', () => {
         });
         const clientWs = createFakeClientWs();
         register('sess-disabled', clientWs);
-        emitDelta('sess-disabled', {
-            type: 'session_delta',
-            data: { type: 'assistant_text_delta', text: 'final answer' },
-        });
+        emitFinalText('sess-disabled', 'final answer');
         emitRuntimeUpdate('sess-disabled', 'IDLE');
         await new Promise((resolve) => setTimeout(resolve, 0));
         expect(FakeDeepgramSocket.instances).toHaveLength(0);
@@ -176,18 +182,12 @@ describe('voiceNarrationService', () => {
     it('synthesizes and forwards audio for the final answer on turn-complete', async () => {
         const clientWs = createFakeClientWs();
         register('sess-speak', clientWs);
-        emitDelta('sess-speak', {
-            type: 'session_delta',
-            data: { type: 'assistant_text_delta', text: 'Hello ' },
-        });
-        emitDelta('sess-speak', {
-            type: 'session_delta',
-            data: { type: 'assistant_text_delta', text: 'world.' },
-        });
+        emitFinalText('sess-speak', 'Hello ');
+        emitFinalText('sess-speak', 'world.');
         emitRuntimeUpdate('sess-speak', 'IDLE');
         await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
-        const ttsSocket = FakeDeepgramSocket.instances[0];
-        expect(ttsSocket.url).toContain('wss://api.deepgram.com/v1/speak');
+        const ttsSocket = socketAt(0);
+        expect(ttsSocket.url).toBe('wss://api.deepgram.com/v2/speak?model=flux-haley-en&encoding=linear16&sample_rate=24000&speed=1');
         expect(mockCryptoService.decrypt).toHaveBeenCalledWith('enc:dg_secret');
         ttsSocket.emit('open');
         expect(JSON.parse(ttsSocket.sentMessages[0])).toEqual({
@@ -203,7 +203,7 @@ describe('voiceNarrationService', () => {
             type: 'audio_chunk',
             data: audioBytes.toString('base64'),
         });
-        ttsSocket.emit('message', Buffer.from(JSON.stringify({ type: 'Flushed' })), false);
+        ttsSocket.emit('message', Buffer.from(JSON.stringify({ type: 'SpeechMetadata' })), false);
         expect(JSON.parse(ttsSocket.sentMessages[2])).toEqual({ type: 'Close' });
         unregister('sess-speak', clientWs);
     });
@@ -220,19 +220,13 @@ describe('voiceNarrationService', () => {
     it('cancelNarration clears the active narration and queued clauses, and clears client playback', async () => {
         const clientWs = createFakeClientWs();
         register('sess-cancel', clientWs);
-        emitDelta('sess-cancel', {
-            type: 'session_delta',
-            data: {
-                type: 'assistant_text_delta',
-                text: 'Sentence one is here. Sentence two is here. ',
-            },
-        });
+        emitFinalText('sess-cancel', 'Sentence one is here. Sentence two is here. ');
         await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
-        const active = FakeDeepgramSocket.instances[0];
+        const active = socketAt(0);
         active.emit('open');
         clientWs.send.mockClear();
         voiceNarrationService.cancelNarration('sess-cancel');
-        expect(JSON.parse(active.sentMessages.at(-1))).toEqual({ type: 'Clear' });
+        expect(JSON.parse(active.sentMessages.at(-1))).toEqual({ type: 'Interrupt' });
         expect(clientWs.send).toHaveBeenCalledWith(JSON.stringify({ type: 'clear_playback' }));
         active.emit('close');
         await new Promise((resolve) => setTimeout(resolve, 0));
@@ -242,31 +236,22 @@ describe('voiceNarrationService', () => {
     it('cancels in-flight narration and clears client playback when a new turn starts mid-speech', async () => {
         const clientWs = createFakeClientWs();
         register('sess-new-turn', clientWs);
-        emitDelta('sess-new-turn', {
-            type: 'session_delta',
-            data: { type: 'assistant_text_delta', text: 'Previous turn is still speaking. ' },
-        });
+        emitFinalText('sess-new-turn', 'Previous turn is still speaking. ');
         await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
-        const active = FakeDeepgramSocket.instances[0];
+        const active = socketAt(0);
         active.emit('open');
         clientWs.send.mockClear();
         emitRuntimeUpdate('sess-new-turn', 'WORKING');
-        expect(JSON.parse(active.sentMessages.at(-1))).toEqual({ type: 'Clear' });
+        expect(JSON.parse(active.sentMessages.at(-1))).toEqual({ type: 'Interrupt' });
         expect(clientWs.send).toHaveBeenCalledWith(JSON.stringify({ type: 'clear_playback' }));
         unregister('sess-new-turn', clientWs);
     });
     it('unregisterConnection cancels active narration and drains the queue', async () => {
         const clientWs = createFakeClientWs();
         register('sess-unregister', clientWs);
-        emitDelta('sess-unregister', {
-            type: 'session_delta',
-            data: {
-                type: 'assistant_text_delta',
-                text: 'Sentence one is here. Sentence two is here. ',
-            },
-        });
+        emitFinalText('sess-unregister', 'Sentence one is here. Sentence two is here. ');
         await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
-        const active = FakeDeepgramSocket.instances[0];
+        const active = socketAt(0);
         active.emit('open');
         unregister('sess-unregister', clientWs);
         active.emit('close');
@@ -276,12 +261,9 @@ describe('voiceNarrationService', () => {
     it('drops audio chunks once the client send buffer is backed up', async () => {
         const clientWs = createFakeClientWs(2_000_000);
         register('sess-backpressure', clientWs);
-        emitDelta('sess-backpressure', {
-            type: 'session_delta',
-            data: { type: 'assistant_text_delta', text: 'A long answer that gets spoken. ' },
-        });
+        emitFinalText('sess-backpressure', 'A long answer that gets spoken. ');
         await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
-        const socket = FakeDeepgramSocket.instances[0];
+        const socket = socketAt(0);
         socket.emit('open');
         socket.emit('message', Buffer.from([1, 2, 3, 4]), true);
         expect(clientWs.send).not.toHaveBeenCalled();
@@ -290,12 +272,9 @@ describe('voiceNarrationService', () => {
     it('drops binary audio frames arriving for a narration already cancelled', async () => {
         const clientWs = createFakeClientWs();
         register('sess-cancelled-audio', clientWs);
-        emitDelta('sess-cancelled-audio', {
-            type: 'session_delta',
-            data: { type: 'assistant_text_delta', text: 'Answer being spoken. ' },
-        });
+        emitFinalText('sess-cancelled-audio', 'Answer being spoken. ');
         await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
-        const socket = FakeDeepgramSocket.instances[0];
+        const socket = socketAt(0);
         socket.emit('open');
         clientWs.send.mockClear();
         voiceNarrationService.cancelNarration('sess-cancelled-audio');
@@ -308,15 +287,9 @@ describe('voiceNarrationService', () => {
         it('strips bold, italic, and inline code before speaking a final-answer clause', async () => {
             const clientWs = createFakeClientWs();
             register('sess-markdown', clientWs);
-            emitDelta('sess-markdown', {
-                type: 'session_delta',
-                data: {
-                    type: 'assistant_text_delta',
-                    text: 'This is **bold**, this is *italic*, and this is `code`. ',
-                },
-            });
+            emitFinalText('sess-markdown', 'This is **bold**, this is *italic*, and this is `code`. ');
             await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
-            const ttsSocket = FakeDeepgramSocket.instances[0];
+            const ttsSocket = socketAt(0);
             ttsSocket.emit('open');
             expect(JSON.parse(ttsSocket.sentMessages[0])).toEqual({
                 type: 'Speak',
@@ -329,7 +302,7 @@ describe('voiceNarrationService', () => {
             register('sess-markdown-2', clientWs);
             emitThinking('sess-markdown-2', '# Plan\n- Check the [docs](https://example.com) first. ');
             await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
-            const ttsSocket = FakeDeepgramSocket.instances[0];
+            const ttsSocket = socketAt(0);
             ttsSocket.emit('open');
             expect(JSON.parse(ttsSocket.sentMessages[0])).toEqual({
                 type: 'Speak',
@@ -340,12 +313,9 @@ describe('voiceNarrationService', () => {
         it('does not treat spaced asterisks (e.g. multiplication) as italic markdown', async () => {
             const clientWs = createFakeClientWs();
             register('sess-math', clientWs);
-            emitDelta('sess-math', {
-                type: 'session_delta',
-                data: { type: 'assistant_text_delta', text: 'The result is 1 * 2 * 3 = 6. ' },
-            });
+            emitFinalText('sess-math', 'The result is 1 * 2 * 3 = 6. ');
             await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
-            const ttsSocket = FakeDeepgramSocket.instances[0];
+            const ttsSocket = socketAt(0);
             ttsSocket.emit('open');
             expect(JSON.parse(ttsSocket.sentMessages[0])).toEqual({
                 type: 'Speak',
@@ -360,7 +330,7 @@ describe('voiceNarrationService', () => {
             register('sess-thinking-1', clientWs);
             emitThinking('sess-thinking-1', 'Let me consider this problem carefully. ');
             await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
-            const ttsSocket = FakeDeepgramSocket.instances[0];
+            const ttsSocket = socketAt(0);
             ttsSocket.emit('open');
             expect(JSON.parse(ttsSocket.sentMessages[0])).toEqual({
                 type: 'Speak',
@@ -376,8 +346,8 @@ describe('voiceNarrationService', () => {
             emitThinking('sess-thinking-2', 'Second thought completed here too. ');
             await new Promise((resolve) => setTimeout(resolve, 0));
             expect(FakeDeepgramSocket.instances).toHaveLength(1);
-            const first = FakeDeepgramSocket.instances[0];
-            first.emit('message', Buffer.from(JSON.stringify({ type: 'Flushed' })), false);
+            const first = socketAt(0);
+            first.emit('message', Buffer.from(JSON.stringify({ type: 'SpeechMetadata' })), false);
             emitThinking('sess-thinking-2', 'Third thought completed here. ');
             await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 2);
             unregister('sess-thinking-2', clientWs);
@@ -387,21 +357,18 @@ describe('voiceNarrationService', () => {
             register('sess-thinking-3', clientWs);
             emitThinking('sess-thinking-3', 'Reasoning about the approach now. ');
             await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
-            const thinkingSocket = FakeDeepgramSocket.instances[0];
+            const thinkingSocket = socketAt(0);
             thinkingSocket.emit('open');
-            emitDelta('sess-thinking-3', {
-                type: 'session_delta',
-                data: { type: 'assistant_text_delta', text: 'The answer is 42.' },
-            });
-            expect(thinkingSocket.sentMessages.some((m) => JSON.parse(m).type === 'Clear')).toBe(true);
+            emitFinalText('sess-thinking-3', 'The answer is 42.');
+            expect(thinkingSocket.sentMessages.some((m) => JSON.parse(m).type === 'Interrupt')).toBe(true);
             expect(clientWs.send.mock.calls.some((call) => JSON.parse(call[0]).type === 'clear_playback')).toBe(true);
             emitThinking('sess-thinking-3', 'This should never be spoken. ');
             await new Promise((resolve) => setTimeout(resolve, 0));
             expect(FakeDeepgramSocket.instances).toHaveLength(1);
-            thinkingSocket.emit('message', Buffer.from(JSON.stringify({ type: 'Cleared' })), false);
+            thinkingSocket.emit('message', Buffer.from(JSON.stringify({ type: 'SpeechInterrupted' })), false);
             emitRuntimeUpdate('sess-thinking-3', 'IDLE');
             await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 2);
-            const finalSocket = FakeDeepgramSocket.instances[1];
+            const finalSocket = socketAt(1);
             finalSocket.emit('open');
             expect(JSON.parse(finalSocket.sentMessages[0])).toEqual({
                 type: 'Speak',
@@ -409,6 +376,76 @@ describe('voiceNarrationService', () => {
             });
             unregister('sess-thinking-3', clientWs);
         });
+        it('settles a cancelled clause on a Warning ack, not just SpeechInterrupted, so later clauses are not stuck forever', async () => {
+            const clientWs = createFakeClientWs();
+            register('sess-thinking-warn', clientWs);
+            emitThinking('sess-thinking-warn', 'Reasoning about the approach now. ');
+            await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
+            const thinkingSocket = socketAt(0);
+            thinkingSocket.emit('open');
+            emitFinalText('sess-thinking-warn', 'The final answer clause. Second final clause. ');
+            thinkingSocket.emit('message', Buffer.from(JSON.stringify({ type: 'Warning', code: 'NO_AUDIO_GENERATED' })), false);
+            await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 2);
+            const first = socketAt(1);
+            first.emit('open');
+            expect(JSON.parse(first.sentMessages[0]).text).toBe('The final answer clause.');
+            first.emit('message', Buffer.from(JSON.stringify({ type: 'SpeechMetadata' })), false);
+            await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 3);
+            const second = socketAt(2);
+            second.emit('open');
+            expect(JSON.parse(second.sentMessages[0]).text).toBe('Second final clause.');
+            unregister('sess-thinking-warn', clientWs);
+        });
+        it('settles an uncancelled clause that Deepgram declined to synthesize, so later clauses still speak', async () => {
+            const clientWs = createFakeClientWs();
+            register('sess-warn-no-audio', clientWs);
+            emitFinalText('sess-warn-no-audio', '🎉🎊✨🎈🎁🎀🥳. Real words follow after it. ');
+            await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
+            const emojiSocket = socketAt(0);
+            emojiSocket.emit('open');
+            expect(JSON.parse(emojiSocket.sentMessages[0]).text).toBe('🎉🎊✨🎈🎁🎀🥳.');
+            emojiSocket.emit('message', Buffer.from(JSON.stringify({ type: 'Warning', code: 'NO_AUDIO_GENERATED' })), false);
+            await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 2);
+            const next = socketAt(1);
+            next.emit('open');
+            expect(JSON.parse(next.sentMessages[0]).text).toBe('Real words follow after it.');
+            unregister('sess-warn-no-audio', clientWs);
+        });
+        it('normalizes a legacy off-grid stored speed before opening the connection', async () => {
+            mockUserSettingsService.get.mockResolvedValue({
+                voiceModeEnabled: true,
+                deepgramApiKeyEncrypted: 'enc:dg_secret',
+                voiceTtsModel: 'flux-haley-en',
+                voiceTtsSpeed: 0.72,
+            });
+            const clientWs = createFakeClientWs();
+            register('sess-legacy-speed', clientWs);
+            emitFinalText('sess-legacy-speed', 'Speaks at a legacy speed. ');
+            await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
+            expect(new URL(socketAt(0).url).searchParams.get('speed')).toBe('0.7');
+            unregister('sess-legacy-speed', clientWs);
+        });
+        it('keeps waiting for SpeechMetadata when a Warning arrives after audio has started, so speech is not clipped', async () => {
+            const clientWs = createFakeClientWs();
+            register('sess-warn-midstream', clientWs);
+            emitFinalText('sess-warn-midstream', 'Audio flows here. Then more words follow. ');
+            await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
+            const socket = socketAt(0);
+            socket.emit('open');
+            socket.emit('message', Buffer.from(JSON.stringify({ type: 'Warning' })), false);
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            expect(FakeDeepgramSocket.instances).toHaveLength(1);
+            socket.emit('message', Buffer.from([1, 2, 3, 4]), true);
+            socket.emit('message', Buffer.from(JSON.stringify({ type: 'Warning' })), false);
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            expect(FakeDeepgramSocket.instances).toHaveLength(1);
+            socket.emit('message', Buffer.from(JSON.stringify({ type: 'SpeechMetadata' })), false);
+            await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 2);
+            const second = socketAt(1);
+            second.emit('open');
+            expect(JSON.parse(second.sentMessages[0]).text).toBe('Then more words follow.');
+            unregister('sess-warn-midstream', clientWs);
+        });
         it('claims activeTts synchronously so a synchronous burst of thinking deltas cannot spawn duplicate sockets', async () => {
             const clientWs = createFakeClientWs();
             register('sess-burst', clientWs);
@@ -425,11 +462,8 @@ describe('voiceNarrationService', () => {
             register('sess-thinking-connecting', clientWs);
             emitThinking('sess-thinking-connecting', 'Reasoning about the approach now. ');
             await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
-            const thinkingSocket = FakeDeepgramSocket.instances[0];
-            emitDelta('sess-thinking-connecting', {
-                type: 'session_delta',
-                data: { type: 'assistant_text_delta', text: 'The answer is 42.' },
-            });
+            const thinkingSocket = socketAt(0);
+            emitFinalText('sess-thinking-connecting', 'The answer is 42.');
             expect(thinkingSocket.sentMessages).toHaveLength(0);
             thinkingSocket.emit('open');
             expect(thinkingSocket.sentMessages).toHaveLength(0);
@@ -443,7 +477,7 @@ describe('voiceNarrationService', () => {
             expect(FakeDeepgramSocket.instances).toHaveLength(0);
             emitThinking('sess-thinking-short', 'Let me look at the file and explain what it does. ');
             await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
-            const ttsSocket = FakeDeepgramSocket.instances[0];
+            const ttsSocket = socketAt(0);
             ttsSocket.emit('open');
             expect(JSON.parse(ttsSocket.sentMessages[0])).toEqual({
                 type: 'Speak',
@@ -461,7 +495,7 @@ describe('voiceNarrationService', () => {
             mockUserSettingsService.get.mockResolvedValue({
                 voiceModeEnabled: true,
                 deepgramApiKeyEncrypted: 'enc:dg_secret',
-                voiceTtsModel: 'aura-2-thalia-en',
+                voiceTtsModel: 'flux-haley-en',
                 voiceTtsSpeed: 1,
             });
             emitThinking('sess-throws', 'This one should work fine now. ');
@@ -473,12 +507,9 @@ describe('voiceNarrationService', () => {
         it('starts speaking the first sentence before the rest of a long answer has arrived', async () => {
             const clientWs = createFakeClientWs();
             register('sess-stream', clientWs);
-            emitDelta('sess-stream', {
-                type: 'session_delta',
-                data: { type: 'assistant_text_delta', text: 'This is the first sentence. ' },
-            });
+            emitFinalText('sess-stream', 'This is the first sentence. ');
             await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
-            const firstSocket = FakeDeepgramSocket.instances[0];
+            const firstSocket = socketAt(0);
             firstSocket.emit('open');
             expect(JSON.parse(firstSocket.sentMessages[0])).toEqual({
                 type: 'Speak',
@@ -489,25 +520,19 @@ describe('voiceNarrationService', () => {
         it('queues later clauses rather than dropping them, and speaks all of them in order', async () => {
             const clientWs = createFakeClientWs();
             register('sess-queue', clientWs);
-            emitDelta('sess-queue', {
-                type: 'session_delta',
-                data: {
-                    type: 'assistant_text_delta',
-                    text: 'Sentence one is here. Sentence two is here. Sentence three is here. ',
-                },
-            });
+            emitFinalText('sess-queue', 'Sentence one is here. Sentence two is here. Sentence three is here. ');
             await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
-            const first = FakeDeepgramSocket.instances[0];
+            const first = socketAt(0);
             first.emit('open');
             expect(JSON.parse(first.sentMessages[0]).text).toBe('Sentence one is here.');
-            first.emit('message', Buffer.from(JSON.stringify({ type: 'Flushed' })), false);
+            first.emit('message', Buffer.from(JSON.stringify({ type: 'SpeechMetadata' })), false);
             await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 2);
-            const second = FakeDeepgramSocket.instances[1];
+            const second = socketAt(1);
             second.emit('open');
             expect(JSON.parse(second.sentMessages[0]).text).toBe('Sentence two is here.');
-            second.emit('message', Buffer.from(JSON.stringify({ type: 'Flushed' })), false);
+            second.emit('message', Buffer.from(JSON.stringify({ type: 'SpeechMetadata' })), false);
             await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 3);
-            const third = FakeDeepgramSocket.instances[2];
+            const third = socketAt(2);
             third.emit('open');
             expect(JSON.parse(third.sentMessages[0]).text).toBe('Sentence three is here.');
             unregister('sess-queue', clientWs);
@@ -515,15 +540,12 @@ describe('voiceNarrationService', () => {
         it('speaks a trailing fragment with no sentence-ending punctuation once the turn completes', async () => {
             const clientWs = createFakeClientWs();
             register('sess-trailing', clientWs);
-            emitDelta('sess-trailing', {
-                type: 'session_delta',
-                data: { type: 'assistant_text_delta', text: 'no punctuation at the end' },
-            });
+            emitFinalText('sess-trailing', 'no punctuation at the end');
             await new Promise((resolve) => setTimeout(resolve, 0));
             expect(FakeDeepgramSocket.instances).toHaveLength(0);
             emitRuntimeUpdate('sess-trailing', 'IDLE');
             await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
-            const socket = FakeDeepgramSocket.instances[0];
+            const socket = socketAt(0);
             socket.emit('open');
             expect(JSON.parse(socket.sentMessages[0])).toEqual({
                 type: 'Speak',
@@ -532,5 +554,66 @@ describe('voiceNarrationService', () => {
             unregister('sess-trailing', clientWs);
         });
     });
+    describe('connection retry', () => {
+        it('retries a handshake failure that happens before open, and still speaks the clause', async () => {
+            const clientWs = createFakeClientWs();
+            register('sess-retry-ok', clientWs);
+            emitFinalText('sess-retry-ok', 'This clause should survive one bad handshake. ');
+            await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
+            const first = socketAt(0);
+            first.emit('error', new Error('socket hang up'));
+            await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 2);
+            const second = socketAt(1);
+            second.emit('open');
+            expect(JSON.parse(second.sentMessages[0])).toEqual({
+                type: 'Speak',
+                text: 'This clause should survive one bad handshake.',
+            });
+            unregister('sess-retry-ok', clientWs);
+        });
+        it('gives up after exhausting retries and still drains the next queued clause', async () => {
+            const clientWs = createFakeClientWs();
+            register('sess-retry-exhausted', clientWs);
+            emitFinalText('sess-retry-exhausted', 'This clause always fails to connect. Second clause speaks fine. ');
+            for (let i = 0; i < 3; i++) {
+                await vi.waitUntil(() => FakeDeepgramSocket.instances.length === i + 1);
+                const socket = socketAt(i);
+                socket.emit('error', new Error('socket hang up'));
+            }
+            await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 4);
+            const secondClause = socketAt(3);
+            secondClause.emit('open');
+            expect(JSON.parse(secondClause.sentMessages[0])).toEqual({
+                type: 'Speak',
+                text: 'Second clause speaks fine.',
+            });
+            unregister('sess-retry-exhausted', clientWs);
+        });
+        it('does not retry a failure that happens after the socket already opened', async () => {
+            const clientWs = createFakeClientWs();
+            register('sess-retry-post-open', clientWs);
+            emitFinalText('sess-retry-post-open', 'Opens fine then drops mid-stream. ');
+            await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
+            const socket = socketAt(0);
+            socket.emit('open');
+            socket.emit('error', new Error('connection reset'));
+            await new Promise((resolve) => setTimeout(resolve, 400));
+            expect(FakeDeepgramSocket.instances).toHaveLength(1);
+            unregister('sess-retry-post-open', clientWs);
+        });
+        it('retries an unexpected-response rejection without an unhandled error event', async () => {
+            const clientWs = createFakeClientWs();
+            register('sess-retry-unexpected', clientWs);
+            emitFinalText('sess-retry-unexpected', 'Rejected with an HTTP status. ');
+            await vi.waitUntil(() => FakeDeepgramSocket.instances.length === 1);
+            const first = socketAt(0);
+            expect(() => first.emit('unexpected-response', {}, { statusCode: 400 })).not.toThrow();
+            expect(first.readyState).toBe(FakeDeepgramSocket.CLOSED);
+            const second = await vi.waitUntil(() => socketAt(1));
+            second.emit('open');
+            expect(JSON.parse(second.sentMessages[0]).text).toBe('Rejected with an HTTP status.');
+            unregister('sess-retry-unexpected', clientWs);
+        });
+    });
 });
 //# sourceMappingURL=voice-narration.service.test.js.map