Cancel pending result-popup measure timers on hideResultPopup; track CaptionService aux-model load state, stop deduplication, and refine abort epochs across restarts; forward per-call AbortSignal through VoiceModeService and LlmGateway to LocalLLMService and abort pull streams plus availability polling on dispose; clear aborted response pointers and gate stale mic start errors in VoiceConversationService; guard AudioCaptureService stopping resume against exited SoX processes and cleanup failed starts; abort LocalSTTService downloadModel polling on dispose; and fail closed when desktopCapturer.getSources rejects in caption loopback setup.
253 lines
8.2 KiB
TypeScript
253 lines
8.2 KiB
TypeScript
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
|
import { IPC_CHANNELS } from '@d3ro/core/ipc-channels'
|
|
import { ErrorCode } from '@d3ro/core/errors'
|
|
import {
|
|
getVoiceConversationService,
|
|
resetVoiceConversationServiceForTests,
|
|
} from '../../../src/main/services/VoiceConversationService'
|
|
|
|
type ChatOptions = {
|
|
signal?: AbortSignal
|
|
maxTokens?: number
|
|
timeoutMs?: number
|
|
keepAlive?: string
|
|
}
|
|
|
|
const mocks = vi.hoisted(() => ({
|
|
audioStart: vi.fn(async () => undefined),
|
|
audioStop: vi.fn(async () => undefined),
|
|
chatStream: vi.fn(),
|
|
premiumCancel: vi.fn(),
|
|
speakSentences: vi.fn(async () => undefined),
|
|
ttsStop: vi.fn(),
|
|
send: vi.fn(),
|
|
}))
|
|
|
|
vi.mock('../../../src/main/services/LoggerService', () => ({
|
|
getLogger: () => ({ info: vi.fn(), warn: vi.fn(), error: vi.fn() }),
|
|
}))
|
|
|
|
vi.mock('../../../src/main/services/AudioCaptureService', () => ({
|
|
getAudioCaptureService: () => ({
|
|
start: mocks.audioStart,
|
|
stop: mocks.audioStop,
|
|
on: vi.fn(),
|
|
off: vi.fn(),
|
|
}),
|
|
}))
|
|
|
|
vi.mock('../../../src/main/services/LocalSTTService', () => ({
|
|
getLocalSTTService: () => ({ initialize: vi.fn(async () => undefined) }),
|
|
}))
|
|
|
|
vi.mock('../../../src/main/services/PremiumLLMService', () => ({
|
|
getPremiumLLMService: () => ({
|
|
cancelGeneration: mocks.premiumCancel,
|
|
isAvailable: () => false,
|
|
}),
|
|
}))
|
|
|
|
vi.mock('../../../src/main/services/LocalLLMService', () => ({
|
|
getLocalLLMService: () => ({
|
|
isAvailable: () => true,
|
|
chatStream: mocks.chatStream,
|
|
}),
|
|
}))
|
|
|
|
vi.mock('../../../src/main/services/TTSPlaybackService', () => ({
|
|
getTTSPlaybackService: () => ({
|
|
speakSentences: mocks.speakSentences,
|
|
stop: mocks.ttsStop,
|
|
}),
|
|
}))
|
|
|
|
vi.mock('../../../src/main/services/SoundEffectService', () => ({
|
|
getSoundEffectService: () => ({ play: vi.fn() }),
|
|
}))
|
|
|
|
vi.mock('../../../src/main/services/ConfigService', () => ({
|
|
configGet: () => undefined,
|
|
}))
|
|
|
|
vi.mock('../../../src/main/services/LicenseService', () => ({
|
|
getLicenseService: () => ({
|
|
canUse: () => ({ allowed: true }),
|
|
promptUpgrade: vi.fn(),
|
|
}),
|
|
}))
|
|
|
|
vi.mock('../../../src/main/windows/WindowManager', () => ({
|
|
getMainWindow: () => ({
|
|
isDestroyed: () => false,
|
|
webContents: { send: mocks.send },
|
|
}),
|
|
}))
|
|
|
|
function waitForAbort(signal: AbortSignal): Promise<void> {
|
|
if (signal.aborted) return Promise.resolve()
|
|
return new Promise((resolve) => signal.addEventListener('abort', () => resolve(), { once: true }))
|
|
}
|
|
|
|
async function* waitUntilAborted(options?: ChatOptions): AsyncGenerator<string, string> {
|
|
if (!options?.signal) throw new Error('Expected caller-owned abort signal')
|
|
await waitForAbort(options.signal)
|
|
return ''
|
|
}
|
|
|
|
describe('VoiceConversationService local response ownership', () => {
|
|
beforeEach(() => {
|
|
resetVoiceConversationServiceForTests()
|
|
vi.clearAllMocks()
|
|
mocks.chatStream.mockImplementation((_messages: unknown, options?: ChatOptions) => waitUntilAborted(options))
|
|
})
|
|
|
|
afterEach(() => {
|
|
resetVoiceConversationServiceForTests()
|
|
})
|
|
|
|
it('rejects a second send without starting a second local chat or adding duplicate history', async () => {
|
|
const service = getVoiceConversationService()
|
|
await service.startSession()
|
|
|
|
const firstResponse = service.sendTextMessage('first')
|
|
await vi.waitFor(() => expect(mocks.chatStream).toHaveBeenCalledTimes(1))
|
|
|
|
await expect(service.sendTextMessage('second')).rejects.toMatchObject({
|
|
code: ErrorCode.ConversationLLMFailed,
|
|
})
|
|
expect(mocks.chatStream).toHaveBeenCalledTimes(1)
|
|
expect(service.getHistory().map((message) => message.content)).toEqual(['first'])
|
|
|
|
service.stopSession()
|
|
await firstResponse
|
|
})
|
|
|
|
it.each([
|
|
['stopSession', (service: ReturnType<typeof getVoiceConversationService>) => service.stopSession()],
|
|
['cancelResponse', (service: ReturnType<typeof getVoiceConversationService>) => service.cancelResponse()],
|
|
])('aborts the local stream signal when %s is called', async (_action, cancel) => {
|
|
const service = getVoiceConversationService()
|
|
await service.startSession()
|
|
|
|
const response = service.sendTextMessage('cancel me')
|
|
await vi.waitFor(() => expect(mocks.chatStream).toHaveBeenCalledTimes(1))
|
|
const options = mocks.chatStream.mock.calls[0][1] as ChatOptions
|
|
|
|
cancel(service)
|
|
|
|
expect(options.signal?.aborted).toBe(true)
|
|
await response
|
|
})
|
|
|
|
it('sets bounded local chat options for voice responses', async () => {
|
|
const service = getVoiceConversationService()
|
|
await service.startSession()
|
|
|
|
const response = service.sendTextMessage('options')
|
|
await vi.waitFor(() => expect(mocks.chatStream).toHaveBeenCalledTimes(1))
|
|
|
|
expect(mocks.chatStream).toHaveBeenCalledWith(
|
|
expect.any(Array),
|
|
expect.objectContaining({
|
|
signal: expect.any(AbortSignal),
|
|
maxTokens: 512,
|
|
timeoutMs: 60_000,
|
|
}),
|
|
)
|
|
|
|
service.stopSession()
|
|
await response
|
|
})
|
|
|
|
it('does not publish late assistant output or start TTS after cancellation', async () => {
|
|
let releaseLateToken: (() => void) | undefined
|
|
const lateToken = new Promise<void>((resolve) => {
|
|
releaseLateToken = resolve
|
|
})
|
|
mocks.chatStream.mockImplementation(() => (async function* (): AsyncGenerator<string, string> {
|
|
await lateToken
|
|
yield 'late answer.'
|
|
return 'late answer.'
|
|
})())
|
|
|
|
const service = getVoiceConversationService()
|
|
await service.startSession()
|
|
const response = service.sendTextMessage('cancel before response')
|
|
await vi.waitFor(() => expect(mocks.chatStream).toHaveBeenCalledTimes(1))
|
|
|
|
service.cancelResponse()
|
|
mocks.send.mockClear()
|
|
releaseLateToken?.()
|
|
await response
|
|
|
|
const lateConversationEvents = mocks.send.mock.calls.filter(([channel]) => (
|
|
channel === IPC_CHANNELS.VOICE_CONVERSATION.ASSISTANT_DELTA
|
|
|| channel === IPC_CHANNELS.VOICE_CONVERSATION.ASSISTANT_MESSAGE
|
|
|| channel === IPC_CHANNELS.VOICE_CONVERSATION.TTS_STARTED
|
|
|| channel === IPC_CHANNELS.VOICE_CONVERSATION.TTS_FINISHED
|
|
))
|
|
expect(lateConversationEvents).toEqual([])
|
|
expect(mocks.speakSentences).not.toHaveBeenCalled()
|
|
expect(service.getHistory().map((message) => message.content)).toEqual(['cancel before response'])
|
|
})
|
|
|
|
it('cancelResponse_followedImmediatelyBySendTextMessage_startsNewTurnWithoutConflict', async () => {
|
|
let releaseFirstStream: (() => void) | undefined
|
|
mocks.chatStream
|
|
.mockImplementationOnce(() => (async function* (): AsyncGenerator<string, string> {
|
|
await new Promise<void>((resolve) => {
|
|
releaseFirstStream = resolve
|
|
})
|
|
return ''
|
|
})())
|
|
.mockImplementationOnce(() => (async function* (): AsyncGenerator<string, string> {
|
|
yield 'second reply.'
|
|
return 'second reply.'
|
|
})())
|
|
|
|
const service = getVoiceConversationService()
|
|
await service.startSession()
|
|
|
|
const firstResponse = service.sendTextMessage('first question')
|
|
await vi.waitFor(() => expect(mocks.chatStream).toHaveBeenCalledTimes(1))
|
|
|
|
service.cancelResponse()
|
|
const secondResponse = service.sendTextMessage('second question')
|
|
releaseFirstStream?.()
|
|
|
|
await expect(secondResponse).resolves.toBeUndefined()
|
|
await firstResponse
|
|
expect(mocks.chatStream).toHaveBeenCalledTimes(2)
|
|
expect(service.getHistory().map((m) => m.content)).toEqual([
|
|
'first question',
|
|
'second question',
|
|
'second reply.',
|
|
])
|
|
})
|
|
|
|
it('startSession_audioStartRejectsAfterStop_doesNotEmitSttErrorOrClobberNewSessionMic', async () => {
|
|
let rejectFirstMic!: (err: Error) => void
|
|
mocks.audioStart
|
|
.mockImplementationOnce(() => new Promise<void>((_resolve, reject) => {
|
|
rejectFirstMic = reject
|
|
}))
|
|
.mockImplementationOnce(async () => undefined)
|
|
|
|
const service = getVoiceConversationService()
|
|
const errorEvents: Array<{ phase: string; message: string }> = []
|
|
service.on('error', (payload) => errorEvents.push(payload))
|
|
|
|
await service.startSession()
|
|
service.stopSession()
|
|
|
|
await service.startSession()
|
|
rejectFirstMic(new Error('stale mic failure'))
|
|
await new Promise((r) => setTimeout(r, 0))
|
|
|
|
expect(errorEvents).toEqual([])
|
|
expect(mocks.send.mock.calls.filter(([channel]) => channel === IPC_CHANNELS.VOICE_CONVERSATION.ERROR)).toEqual([])
|
|
|
|
service.stopSession()
|
|
expect(mocks.audioStop).toHaveBeenCalledTimes(2)
|
|
})
|
|
})
|