@mingxy/ocosay 1.0.0

package/tests/stream-reader.test.ts

@@ -0,0 +1,269 @@
+import { StreamReader } from '../src/core/stream-reader'
+import { StreamState } from '../src/core/types'
+
+describe('StreamReader', () => {
+  let streamReader: StreamReader
+
+  beforeEach(() => {
+    streamReader = new StreamReader(30, 2000)
+  })
+
+  afterEach(() => {
+    streamReader.reset()
+  })
+
+  describe('initialization', () => {
+    it('should create StreamReader with default options', () => {
+      const reader = new StreamReader()
+      expect(reader).toBeInstanceOf(StreamReader)
+      reader.reset()
+    })
+
+    it('should create StreamReader with custom buffer size and timeout', () => {
+      const reader = new StreamReader(50, 3000)
+      expect(reader).toBeInstanceOf(StreamReader)
+      reader.reset()
+    })
+  })
+
+  describe('handleDelta', () => {
+    it('should transition from IDLE to BUFFERING on first delta', () => {
+      streamReader.handleDelta('session1', 'msg1', 'part1', '你好')
+      expect(streamReader.getState()).toBe(StreamState.BUFFERING)
+    })
+
+    it('should accumulate delta in buffer', () => {
+      streamReader.handleDelta('session1', 'msg1', 'part1', '你好')
+      expect(streamReader.getBuffer()).toBe('你好')
+    })
+
+    it('should update session ID and message ID', () => {
+      streamReader.handleDelta('session1', 'msg1', 'part1', '你好')
+      expect(streamReader.getSessionID()).toBe('session1')
+      expect(streamReader.getMessageID()).toBe('msg1')
+      expect(streamReader.getPartID()).toBe('part1')
+    })
+
+    it('should emit streamStart event on first delta', () => {
+      const startCallback = jest.fn()
+      streamReader.on('streamStart', startCallback)
+      streamReader.handleDelta('session1', 'msg1', 'part1', '你好')
+      expect(startCallback).toHaveBeenCalledTimes(1)
+    })
+
+    it('should accumulate multiple deltas', () => {
+      streamReader.handleDelta('session1', 'msg1', 'part1', '你好')
+      streamReader.handleDelta('session1', 'msg1', 'part1', '世界')
+      expect(streamReader.getBuffer()).toBe('你好世界')
+    })
+  })
+
+  describe('handleEnd', () => {
+    it('should emit streamEnd event', () => {
+      const endCallback = jest.fn()
+      streamReader.on('streamEnd', endCallback)
+      streamReader.handleEnd()
+      expect(endCallback).toHaveBeenCalledTimes(1)
+    })
+
+    it('should flush remaining buffer before ending', () => {
+      const textReadyCallback = jest.fn()
+      streamReader.on('textReady', textReadyCallback)
+      streamReader.handleDelta('session1', 'msg1', 'part1', '测试文本')
+      streamReader.handleEnd()
+      expect(textReadyCallback).toHaveBeenCalledWith('测试文本')
+    })
+
+    it('should not emit textReady for empty buffer', () => {
+      const textReadyCallback = jest.fn()
+      streamReader.on('textReady', textReadyCallback)
+      streamReader.handleEnd()
+      expect(textReadyCallback).not.toHaveBeenCalled()
+    })
+
+    it('should transition to ENDED state', () => {
+      streamReader.handleEnd()
+      expect(streamReader.getState()).toBe(StreamState.ENDED)
+    })
+
+    it('should handle multiple handleEnd calls gracefully', () => {
+      const textReadyCallback = jest.fn()
+      streamReader.on('textReady', textReadyCallback)
+      streamReader.handleDelta('session1', 'msg1', 'part1', '测试')
+      streamReader.handleEnd()
+      streamReader.handleEnd() // Second call should be ignored
+      expect(textReadyCallback).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('sentence boundary detection (shouldFlush)', () => {
+    it('should flush on Chinese period 。', () => {
+      const textReadyCallback = jest.fn()
+      streamReader.on('textReady', textReadyCallback)
+      streamReader.handleDelta('session1', 'msg1', 'part1', '你好。')
+      expect(textReadyCallback).toHaveBeenCalledWith('你好。')
+    })
+
+    it('should flush on Chinese exclamation ！', () => {
+      const textReadyCallback = jest.fn()
+      streamReader.on('textReady', textReadyCallback)
+      streamReader.handleDelta('session1', 'msg1', 'part1', '你好！')
+      expect(textReadyCallback).toHaveBeenCalledWith('你好！')
+    })
+
+    it('should flush on Chinese question ？', () => {
+      const textReadyCallback = jest.fn()
+      streamReader.on('textReady', textReadyCallback)
+      streamReader.handleDelta('session1', 'msg1', 'part1', '你好？')
+      expect(textReadyCallback).toHaveBeenCalledWith('你好？')
+    })
+
+    it('should flush on English period .', () => {
+      const textReadyCallback = jest.fn()
+      streamReader.on('textReady', textReadyCallback)
+      streamReader.handleDelta('session1', 'msg1', 'part1', 'Hello.')
+      expect(textReadyCallback).toHaveBeenCalledWith('Hello.')
+    })
+
+    it('should flush on English exclamation !', () => {
+      const textReadyCallback = jest.fn()
+      streamReader.on('textReady', textReadyCallback)
+      streamReader.handleDelta('session1', 'msg1', 'part1', 'Hello!')
+      expect(textReadyCallback).toHaveBeenCalledWith('Hello!')
+    })
+
+    it('should flush on English question ?', () => {
+      const textReadyCallback = jest.fn()
+      streamReader.on('textReady', textReadyCallback)
+      streamReader.handleDelta('session1', 'msg1', 'part1', 'Hello?')
+      expect(textReadyCallback).toHaveBeenCalledWith('Hello?')
+    })
+
+    it('should flush on Chinese ellipsis ……', () => {
+      const textReadyCallback = jest.fn()
+      streamReader.on('textReady', textReadyCallback)
+      streamReader.handleDelta('session1', 'msg1', 'part1', '你好……')
+      expect(textReadyCallback).toHaveBeenCalledWith('你好……')
+    })
+
+    it('should flush when buffer reaches bufferSize', () => {
+      const smallBufferReader = new StreamReader(3, 2000)
+      const textReadyCallback = jest.fn()
+      smallBufferReader.on('textReady', textReadyCallback)
+      smallBufferReader.handleDelta('session1', 'msg1', 'part1', '你好世')
+      expect(textReadyCallback).toHaveBeenCalled()
+      smallBufferReader.reset()
+    })
+  })
+
+  describe('timeout mechanism', () => {
+    it('should flush buffer after timeout', async () => {
+      const shortTimeoutReader = new StreamReader(100, 50)
+      const textReadyCallback = jest.fn()
+      shortTimeoutReader.on('textReady', textReadyCallback)
+      shortTimeoutReader.handleDelta('session1', 'msg1', 'part1', '测试')
+      expect(textReadyCallback).not.toHaveBeenCalled()
+      await new Promise(resolve => setTimeout(resolve, 100))
+      expect(textReadyCallback).toHaveBeenCalledWith('测试')
+      shortTimeoutReader.reset()
+    })
+
+    it('should reset timeout on new delta', async () => {
+      const shortTimeoutReader = new StreamReader(100, 100)
+      const textReadyCallback = jest.fn()
+      shortTimeoutReader.on('textReady', textReadyCallback)
+      shortTimeoutReader.handleDelta('session1', 'msg1', 'part1', '第一')
+      await new Promise(resolve => setTimeout(resolve, 50))
+      shortTimeoutReader.handleDelta('session1', 'msg1', 'part1', '第二')
+      await new Promise(resolve => setTimeout(resolve, 50))
+      expect(textReadyCallback).not.toHaveBeenCalled()
+      await new Promise(resolve => setTimeout(resolve, 100))
+      expect(textReadyCallback).toHaveBeenCalledWith('第一第二')
+      shortTimeoutReader.reset()
+    })
+  })
+
+  describe('reset', () => {
+    it('should clear buffer', () => {
+      streamReader.handleDelta('session1', 'msg1', 'part1', '测试')
+      streamReader.reset()
+      expect(streamReader.getBuffer()).toBe('')
+    })
+
+    it('should transition to IDLE state', () => {
+      streamReader.handleDelta('session1', 'msg1', 'part1', '测试')
+      streamReader.reset()
+      expect(streamReader.getState()).toBe(StreamState.IDLE)
+    })
+
+    it('should clear session/message/part IDs', () => {
+      streamReader.handleDelta('session1', 'msg1', 'part1', '测试')
+      streamReader.reset()
+      expect(streamReader.getSessionID()).toBeUndefined()
+      expect(streamReader.getMessageID()).toBeUndefined()
+      expect(streamReader.getPartID()).toBeUndefined()
+    })
+  })
+
+  describe('isActive', () => {
+    it('should return true when BUFFERING', () => {
+      streamReader.handleDelta('session1', 'msg1', 'part1', '测试')
+      expect(streamReader.isActive()).toBe(true)
+    })
+
+    it('should return false when IDLE', () => {
+      expect(streamReader.isActive()).toBe(false)
+    })
+
+    it('should return false when ENDED', () => {
+      streamReader.handleEnd()
+      expect(streamReader.isActive()).toBe(false)
+    })
+  })
+
+  describe('start', () => {
+    it('should transition from IDLE to BUFFERING', () => {
+      streamReader.start()
+      expect(streamReader.getState()).toBe(StreamState.BUFFERING)
+    })
+
+    it('should emit streamStart event', () => {
+      const startCallback = jest.fn()
+      streamReader.on('streamStart', startCallback)
+      streamReader.start()
+      expect(startCallback).toHaveBeenCalledTimes(1)
+    })
+
+    it('should not emit streamStart if already BUFFERING', () => {
+      const startCallback = jest.fn()
+      streamReader.on('streamStart', startCallback)
+      streamReader.start()
+      streamReader.start()
+      expect(startCallback).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('handleError', () => {
+    it('should emit streamError event', () => {
+      const errorCallback = jest.fn()
+      streamReader.on('streamError', errorCallback)
+      const { TTSError, TTSErrorCode } = require('../src/core/types')
+      streamReader.handleError(new TTSError('Test error', TTSErrorCode.UNKNOWN, 'test'))
+      expect(errorCallback).toHaveBeenCalled()
+    })
+
+    it('should reset to IDLE state', () => {
+      streamReader.handleDelta('session1', 'msg1', 'part1', '测试')
+      const { TTSError, TTSErrorCode } = require('../src/core/types')
+      streamReader.handleError(new TTSError('Test error', TTSErrorCode.UNKNOWN, 'test'))
+      expect(streamReader.getState()).toBe(StreamState.IDLE)
+    })
+
+    it('should clear buffer', () => {
+      streamReader.handleDelta('session1', 'msg1', 'part1', '测试')
+      const { TTSError, TTSErrorCode } = require('../src/core/types')
+      streamReader.handleError(new TTSError('Test error', TTSErrorCode.UNKNOWN, 'test'))
+      expect(streamReader.getBuffer()).toBe('')
+    })
+  })
+})

package/tests/streaming-synthesizer.test.ts

@@ -0,0 +1,225 @@
+import { StreamingSynthesizer } from '../src/core/streaming-synthesizer'
+import { TTSProvider, TTSError, TTSErrorCode, AudioResult, SpeakOptions, TTSCapabilities } from '../src/core/types'
+
+class MockTTSProvider implements TTSProvider {
+  name = 'mock-stream'
+  capabilities: TTSCapabilities = { speak: true, stream: true }
+
+  async initialize(): Promise<void> {}
+  async destroy(): Promise<void> {}
+  async pause(): Promise<void> {}
+  async resume(): Promise<void> {}
+  async stop(): Promise<void> {}
+  async listVoices() { return [] }
+  getCapabilities(): TTSCapabilities { return this.capabilities }
+
+  async speak(text: string, options?: SpeakOptions): Promise<AudioResult> {
+    if (text === 'error') {
+      throw new TTSError('Synthesize error', TTSErrorCode.UNKNOWN, this.name)
+    }
+    return {
+      audioData: Buffer.from([1, 2, 3]),
+      format: 'mp3',
+      isStream: false,
+      duration: 1.0
+    }
+  }
+}
+
+class MockStreamingProvider implements TTSProvider {
+  name = 'mock-streaming'
+  capabilities: TTSCapabilities = { speak: true, stream: true }
+
+  async initialize(): Promise<void> {}
+  async destroy(): Promise<void> {}
+  async pause(): Promise<void> {}
+  async resume(): Promise<void> {}
+  async stop(): Promise<void> {}
+  async listVoices() { return [] }
+  getCapabilities(): TTSCapabilities { return this.capabilities }
+
+  async speak(text: string, options?: SpeakOptions): Promise<AudioResult> {
+    if (text === 'error') {
+      throw new TTSError('Synthesize error', TTSErrorCode.UNKNOWN, this.name)
+    }
+    const chunks = ['chunk1', 'chunk2', 'chunk3']
+    const stream = new ReadableStream({
+      pull(controller) {
+        for (const chunk of chunks) {
+          controller.enqueue(Buffer.from(chunk))
+        }
+        controller.close()
+      }
+    })
+    return {
+      audioData: stream,
+      format: 'mp3',
+      isStream: true,
+      duration: 1.0
+    }
+  }
+}
+
+describe('StreamingSynthesizer', () => {
+  let synthesizer: StreamingSynthesizer
+  let mockProvider: MockTTSProvider
+  let mockStreamingProvider: MockStreamingProvider
+
+  beforeEach(() => {
+    mockProvider = new MockTTSProvider()
+    mockStreamingProvider = new MockStreamingProvider()
+  })
+
+  afterEach(() => {
+    synthesizer?.reset()
+  })
+
+  describe('initialization', () => {
+    it('should create synthesizer with options', () => {
+      synthesizer = new StreamingSynthesizer({
+        provider: mockProvider,
+        voice: 'test-voice',
+        speed: 1.0,
+        volume: 1.0,
+        pitch: 1.0
+      })
+      expect(synthesizer).toBeInstanceOf(StreamingSynthesizer)
+    })
+
+    it('should create synthesizer with minimal options', () => {
+      synthesizer = new StreamingSynthesizer({
+        provider: mockProvider
+      })
+      expect(synthesizer).toBeInstanceOf(StreamingSynthesizer)
+    })
+  })
+
+  describe('synthesize', () => {
+    it('should call provider.speak with correct options', async () => {
+      synthesizer = new StreamingSynthesizer({
+        provider: mockProvider,
+        voice: 'test-voice',
+        speed: 1.5,
+        volume: 0.8,
+        pitch: 1.2
+      })
+      const speakSpy = jest.spyOn(mockProvider, 'speak')
+      await synthesizer.synthesize('test text')
+      expect(speakSpy).toHaveBeenCalledWith('test text', expect.objectContaining({
+        model: 'stream',
+        voice: 'test-voice',
+        speed: 1.5,
+        volume: 0.8,
+        pitch: 1.2
+      }))
+    })
+
+    it('should return early for empty text', async () => {
+      synthesizer = new StreamingSynthesizer({ provider: mockProvider })
+      const speakSpy = jest.spyOn(mockProvider, 'speak')
+      await synthesizer.synthesize('')
+      expect(speakSpy).not.toHaveBeenCalled()
+    })
+
+    it('should return early for whitespace-only text', async () => {
+      synthesizer = new StreamingSynthesizer({ provider: mockProvider })
+      const speakSpy = jest.spyOn(mockProvider, 'speak')
+      await synthesizer.synthesize('   ')
+      expect(speakSpy).not.toHaveBeenCalled()
+    })
+
+    it('should emit done event on success', async () => {
+      synthesizer = new StreamingSynthesizer({ provider: mockProvider })
+      const doneCallback = jest.fn()
+      synthesizer.on('done', doneCallback)
+      await synthesizer.synthesize('test text')
+      expect(doneCallback).toHaveBeenCalledTimes(1)
+    })
+
+    it('should emit error event on provider error', async () => {
+      synthesizer = new StreamingSynthesizer({ provider: mockProvider })
+      const errorCallback = jest.fn()
+      synthesizer.on('error', errorCallback)
+      await synthesizer.synthesize('error')
+      expect(errorCallback).toHaveBeenCalledTimes(1)
+    })
+
+    it('should accumulate audio chunks', async () => {
+      synthesizer = new StreamingSynthesizer({ provider: mockProvider })
+      const chunkCallback = jest.fn()
+      synthesizer.on('chunk', chunkCallback)
+      await synthesizer.synthesize('test text')
+      expect(chunkCallback).toHaveBeenCalled()
+      expect(synthesizer.getAudioChunks().length).toBeGreaterThan(0)
+    })
+  })
+
+  describe('processAudioResult with Buffer', () => {
+    it('should emit chunk for Buffer audioData', async () => {
+      synthesizer = new StreamingSynthesizer({ provider: mockProvider })
+      const chunkCallback = jest.fn()
+      synthesizer.on('chunk', chunkCallback)
+      await synthesizer.synthesize('test text')
+      expect(chunkCallback).toHaveBeenCalledWith(Buffer.from([1, 2, 3]))
+    })
+  })
+
+  describe('processAudioResult with ReadableStream', () => {
+    it('should emit multiple chunks for stream audioData', async () => {
+      synthesizer = new StreamingSynthesizer({ provider: mockStreamingProvider })
+      const chunks: Buffer[] = []
+      synthesizer.on('chunk', (chunk: Buffer) => chunks.push(chunk))
+      await synthesizer.synthesize('test text')
+      expect(chunks.length).toBe(3)
+      expect(chunks[0].toString()).toBe('chunk1')
+      expect(chunks[1].toString()).toBe('chunk2')
+      expect(chunks[2].toString()).toBe('chunk3')
+    })
+  })
+
+  describe('reset', () => {
+    it('should clear accumulated audio chunks', async () => {
+      synthesizer = new StreamingSynthesizer({ provider: mockProvider })
+      await synthesizer.synthesize('test text')
+      expect(synthesizer.getAudioChunks().length).toBeGreaterThan(0)
+      synthesizer.reset()
+      expect(synthesizer.getAudioChunks()).toEqual([])
+    })
+  })
+
+  describe('getAudioChunks', () => {
+    it('should return copy of chunks array', async () => {
+      synthesizer = new StreamingSynthesizer({ provider: mockProvider })
+      await synthesizer.synthesize('test text')
+      const chunks1 = synthesizer.getAudioChunks()
+      const chunks2 = synthesizer.getAudioChunks()
+      expect(chunks1).toEqual(chunks2)
+      chunks1.push(Buffer.from([99]))
+      expect(chunks2.length).toBe(synthesizer.getAudioChunks().length)
+    })
+  })
+
+  describe('error handling', () => {
+    it('should wrap non-TTSError in TTSError', async () => {
+      class ErrorProvider implements TTSProvider {
+        name = 'error-provider'
+        capabilities: TTSCapabilities = { speak: true }
+        async initialize() {}
+        async destroy() {}
+        async speak(): Promise<AudioResult> { throw new Error('Raw error') }
+        async pause() {}
+        async resume() {}
+        async stop() {}
+        async listVoices() { return [] }
+        getCapabilities(): TTSCapabilities { return this.capabilities }
+      }
+      synthesizer = new StreamingSynthesizer({ provider: new ErrorProvider() })
+      const errorCallback = jest.fn()
+      synthesizer.on('error', errorCallback)
+      await synthesizer.synthesize('test')
+      expect(errorCallback).toHaveBeenCalledWith(expect.objectContaining({
+        name: 'TTSError'
+      }))
+    })
+  })
+})